diff options
Diffstat (limited to 'spec/ruby/core/array')
115 files changed, 981 insertions, 1053 deletions
diff --git a/spec/ruby/core/array/allocate_spec.rb b/spec/ruby/core/array/allocate_spec.rb index 04f7c0d0ad..c9eceef590 100644 --- a/spec/ruby/core/array/allocate_spec.rb +++ b/spec/ruby/core/array/allocate_spec.rb @@ -3,7 +3,7 @@ require_relative '../../spec_helper' describe "Array.allocate" do it "returns an instance of Array" do ary = Array.allocate - ary.should be_an_instance_of(Array) + ary.should.instance_of?(Array) end it "returns a fully-formed instance of Array" do @@ -14,6 +14,6 @@ describe "Array.allocate" do end it "does not accept any arguments" do - -> { Array.allocate(1) }.should raise_error(ArgumentError) + -> { Array.allocate(1) }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/array/append_spec.rb b/spec/ruby/core/array/append_spec.rb index c12473dc07..de0e56b513 100644 --- a/spec/ruby/core/array/append_spec.rb +++ b/spec/ruby/core/array/append_spec.rb @@ -10,8 +10,8 @@ describe "Array#<<" do it "returns self to allow chaining" do a = [] b = a - (a << 1).should equal(b) - (a << 2 << 3).should equal(b) + (a << 1).should.equal?(b) + (a << 2 << 3).should.equal?(b) end it "correctly resizes the Array" do @@ -31,7 +31,7 @@ describe "Array#<<" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array << 5 }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array << 5 }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/assoc_spec.rb b/spec/ruby/core/array/assoc_spec.rb index f0be3de795..a5026cf5d4 100644 --- a/spec/ruby/core/array/assoc_spec.rb +++ b/spec/ruby/core/array/assoc_spec.rb @@ -10,14 +10,14 @@ describe "Array#assoc" do s5 = [:letters, "a", "i", "u"] s_nil = [nil, nil] a = [s1, s2, s3, s4, s5, s_nil] - a.assoc(s1.first).should equal(s1) - a.assoc(s2.first).should equal(s2) - a.assoc(s3.first).should equal(s3) - a.assoc(s4.first).should equal(s1) - a.assoc(s5.first).should equal(s2) - a.assoc(s_nil.first).should equal(s_nil) - a.assoc(4).should equal(s3) - a.assoc("key not in array").should be_nil + a.assoc(s1.first).should.equal?(s1) + a.assoc(s2.first).should.equal?(s2) + a.assoc(s3.first).should.equal?(s3) + a.assoc(s4.first).should.equal?(s1) + a.assoc(s5.first).should.equal?(s2) + a.assoc(s_nil.first).should.equal?(s_nil) + a.assoc(4).should.equal?(s3) + a.assoc("key not in array").should == nil end it "calls == on first element of each array" do @@ -25,17 +25,17 @@ describe "Array#assoc" do key2 = mock('key2') items = [['not it', 1], [ArraySpecs::AssocKey.new, 2], ['na', 3]] - items.assoc(key1).should equal(items[1]) - items.assoc(key2).should be_nil + items.assoc(key1).should.equal?(items[1]) + items.assoc(key2).should == nil end it "ignores any non-Array elements" do - [1, 2, 3].assoc(2).should be_nil + [1, 2, 3].assoc(2).should == nil s1 = [4] s2 = [5, 4, 3] a = ["foo", [], s1, s2, nil, []] - a.assoc(s1.first).should equal(s1) - a.assoc(s2.first).should equal(s2) + a.assoc(s1.first).should.equal?(s1) + a.assoc(s2.first).should.equal?(s2) end it "calls to_ary on non-array elements" do @@ -44,9 +44,9 @@ describe "Array#assoc" do a = [s1, s2] s1.should_not_receive(:to_ary) - a.assoc(s1.first).should equal(s1) + a.assoc(s1.first).should.equal?(s1) a.assoc(2).should == [2, 3] - s2.called.should equal(:to_ary) + s2.called.should.equal?(:to_ary) end end diff --git a/spec/ruby/core/array/at_spec.rb b/spec/ruby/core/array/at_spec.rb index 8bc789fef7..3c7c99fdff 100644 --- a/spec/ruby/core/array/at_spec.rb +++ b/spec/ruby/core/array/at_spec.rb @@ -47,10 +47,10 @@ describe "Array#at" do end it "raises a TypeError when the passed argument can't be coerced to Integer" do - -> { [].at("cat") }.should raise_error(TypeError) + -> { [].at("cat") }.should.raise(TypeError) end it "raises an ArgumentError when 2 or more arguments are passed" do - -> { [:a, :b].at(0,1) }.should raise_error(ArgumentError) + -> { [:a, :b].at(0,1) }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/array/bsearch_index_spec.rb b/spec/ruby/core/array/bsearch_index_spec.rb index 94d85b37f3..e1d5eb66bb 100644 --- a/spec/ruby/core/array/bsearch_index_spec.rb +++ b/spec/ruby/core/array/bsearch_index_spec.rb @@ -8,11 +8,11 @@ describe "Array#bsearch_index" do end it "returns an Enumerator" do - @enum.should be_an_instance_of(Enumerator) + @enum.should.instance_of?(Enumerator) end it "returns an Enumerator with unknown size" do - @enum.size.should be_nil + @enum.size.should == nil end it "returns index of element when block condition is satisfied" do @@ -21,11 +21,11 @@ describe "Array#bsearch_index" do end it "raises a TypeError when block returns a String" do - -> { [1, 2, 3].bsearch_index { "not ok" } }.should raise_error(TypeError) + -> { [1, 2, 3].bsearch_index { "not ok" } }.should.raise(TypeError) end it "returns nil when block is empty" do - [1, 2, 3].bsearch_index {}.should be_nil + [1, 2, 3].bsearch_index {}.should == nil end context "minimum mode" do @@ -40,8 +40,8 @@ describe "Array#bsearch_index" do end it "returns nil when block condition is never satisfied" do - @array.bsearch_index { false }.should be_nil - @array.bsearch_index { |x| x >= 100 }.should be_nil + @array.bsearch_index { false }.should == nil + @array.bsearch_index { |x| x >= 100 }.should == nil end end @@ -51,30 +51,30 @@ describe "Array#bsearch_index" do end it "returns the index of any matched elements where element is between 4 <= x < 8" do - [1, 2].should include(@array.bsearch_index { |x| 1 - x / 4 }) + [1, 2].should.include?(@array.bsearch_index { |x| 1 - x / 4 }) end it "returns the index of any matched elements where element is between 8 <= x < 10" do - @array.bsearch_index { |x| 4 - x / 2 }.should be_nil + @array.bsearch_index { |x| 4 - x / 2 }.should == nil end it "returns nil when block never returns 0" do - @array.bsearch_index { |x| 1 }.should be_nil - @array.bsearch_index { |x| -1 }.should be_nil + @array.bsearch_index { |x| 1 }.should == nil + @array.bsearch_index { |x| -1 }.should == nil end context "magnitude does not effect the result" do it "returns the index of any matched elements where element is between 4n <= xn < 8n" do - [1, 2].should include(@array.bsearch_index { |x| (1 - x / 4) * (2**100) }) + [1, 2].should.include?(@array.bsearch_index { |x| (1 - x / 4) * (2**100) }) end it "returns nil when block never returns 0" do - @array.bsearch_index { |x| 1 * (2**100) }.should be_nil - @array.bsearch_index { |x| (-1) * (2**100) }.should be_nil + @array.bsearch_index { |x| 1 * (2**100) }.should == nil + @array.bsearch_index { |x| (-1) * (2**100) }.should == nil end it "handles values from Integer#coerce" do - [1, 2].should include(@array.bsearch_index { |x| (2**100).coerce((1 - x / 4) * (2**100)).first }) + [1, 2].should.include?(@array.bsearch_index { |x| (2**100).coerce((1 - x / 4) * (2**100)).first }) end end end diff --git a/spec/ruby/core/array/bsearch_spec.rb b/spec/ruby/core/array/bsearch_spec.rb index 8fa6245dbf..12aec60654 100644 --- a/spec/ruby/core/array/bsearch_spec.rb +++ b/spec/ruby/core/array/bsearch_spec.rb @@ -3,26 +3,26 @@ require_relative '../enumerable/shared/enumeratorized' describe "Array#bsearch" do it "returns an Enumerator when not passed a block" do - [1].bsearch.should be_an_instance_of(Enumerator) + [1].bsearch.should.instance_of?(Enumerator) end it_behaves_like :enumeratorized_with_unknown_size, :bsearch, [1,2,3] it "raises a TypeError if the block returns an Object" do - -> { [1].bsearch { Object.new } }.should raise_error(TypeError) + -> { [1].bsearch { Object.new } }.should.raise(TypeError) end it "raises a TypeError if the block returns a String" do - -> { [1].bsearch { "1" } }.should raise_error(TypeError) + -> { [1].bsearch { "1" } }.should.raise(TypeError) end context "with a block returning true or false" do it "returns nil if the block returns false for every element" do - [0, 1, 2, 3].bsearch { |x| x > 3 }.should be_nil + [0, 1, 2, 3].bsearch { |x| x > 3 }.should == nil end it "returns nil if the block returns nil for every element" do - [0, 1, 2, 3].bsearch { |x| nil }.should be_nil + [0, 1, 2, 3].bsearch { |x| nil }.should == nil end it "returns element at zero if the block returns true for every element" do @@ -38,21 +38,21 @@ describe "Array#bsearch" do context "with a block returning negative, zero, positive numbers" do it "returns nil if the block returns less than zero for every element" do - [0, 1, 2, 3].bsearch { |x| x <=> 5 }.should be_nil + [0, 1, 2, 3].bsearch { |x| x <=> 5 }.should == nil end it "returns nil if the block returns greater than zero for every element" do - [0, 1, 2, 3].bsearch { |x| x <=> -1 }.should be_nil + [0, 1, 2, 3].bsearch { |x| x <=> -1 }.should == nil end it "returns nil if the block never returns zero" do - [0, 1, 3, 4].bsearch { |x| x <=> 2 }.should be_nil + [0, 1, 3, 4].bsearch { |x| x <=> 2 }.should == nil end it "accepts (+/-)Float::INFINITY from the block" do - [0, 1, 3, 4].bsearch { |x| Float::INFINITY }.should be_nil - [0, 1, 3, 4].bsearch { |x| -Float::INFINITY }.should be_nil + [0, 1, 3, 4].bsearch { |x| Float::INFINITY }.should == nil + [0, 1, 3, 4].bsearch { |x| -Float::INFINITY }.should == nil end it "returns an element at an index for which block returns 0.0" do @@ -62,17 +62,17 @@ describe "Array#bsearch" do it "returns an element at an index for which block returns 0" do result = [0, 1, 2, 3, 4].bsearch { |x| x < 1 ? 1 : x > 3 ? -1 : 0 } - [1, 2].should include(result) + [1, 2].should.include?(result) end end context "with a block that calls break" do it "returns nil if break is called without a value" do - ['a', 'b', 'c'].bsearch { |v| break }.should be_nil + ['a', 'b', 'c'].bsearch { |v| break }.should == nil end it "returns nil if break is called with a nil value" do - ['a', 'b', 'c'].bsearch { |v| break nil }.should be_nil + ['a', 'b', 'c'].bsearch { |v| break nil }.should == nil end it "returns object if break is called with an object" do diff --git a/spec/ruby/core/array/clear_spec.rb b/spec/ruby/core/array/clear_spec.rb index 81ba56e01e..15778f864f 100644 --- a/spec/ruby/core/array/clear_spec.rb +++ b/spec/ruby/core/array/clear_spec.rb @@ -4,13 +4,13 @@ require_relative 'fixtures/classes' describe "Array#clear" do it "removes all elements" do a = [1, 2, 3, 4] - a.clear.should equal(a) + a.clear.should.equal?(a) a.should == [] end it "returns self" do a = [1] - a.should equal a.clear + a.should.equal? a.clear end it "leaves the Array empty" do @@ -21,12 +21,12 @@ describe "Array#clear" do end it "does not accept any arguments" do - -> { [1].clear(true) }.should raise_error(ArgumentError) + -> { [1].clear(true) }.should.raise(ArgumentError) end it "raises a FrozenError on a frozen array" do a = [1] a.freeze - -> { a.clear }.should raise_error(FrozenError) + -> { a.clear }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/clone_spec.rb b/spec/ruby/core/array/clone_spec.rb index e22a6c6d53..7ce9d40a81 100644 --- a/spec/ruby/core/array/clone_spec.rb +++ b/spec/ruby/core/array/clone_spec.rb @@ -23,9 +23,9 @@ describe "Array#clone" do aa = a.clone bb = b.clone - a.respond_to?(:a_singleton_method).should be_true - b.respond_to?(:a_singleton_method).should be_false - aa.respond_to?(:a_singleton_method).should be_true - bb.respond_to?(:a_singleton_method).should be_false + a.respond_to?(:a_singleton_method).should == true + b.respond_to?(:a_singleton_method).should == false + aa.respond_to?(:a_singleton_method).should == true + bb.respond_to?(:a_singleton_method).should == false end end diff --git a/spec/ruby/core/array/combination_spec.rb b/spec/ruby/core/array/combination_spec.rb index f16d6f98fc..ac570687ca 100644 --- a/spec/ruby/core/array/combination_spec.rb +++ b/spec/ruby/core/array/combination_spec.rb @@ -6,11 +6,11 @@ describe "Array#combination" do end it "returns an enumerator when no block is provided" do - @array.combination(2).should be_an_instance_of(Enumerator) + @array.combination(2).should.instance_of?(Enumerator) end it "returns self when a block is given" do - @array.combination(2){}.should equal(@array) + @array.combination(2){}.should.equal?(@array) end it "yields nothing for out of bounds length and return self" do @@ -30,7 +30,7 @@ describe "Array#combination" do it "yields a copy of self if the argument is the size of the receiver" do r = @array.combination(4).to_a r.should == [@array] - r[0].should_not equal(@array) + r[0].should_not.equal?(@array) end it "yields [] when length is 0" do diff --git a/spec/ruby/core/array/compact_spec.rb b/spec/ruby/core/array/compact_spec.rb index 83b3fa2a89..dbcd16da35 100644 --- a/spec/ruby/core/array/compact_spec.rb +++ b/spec/ruby/core/array/compact_spec.rb @@ -15,30 +15,30 @@ describe "Array#compact" do it "does not return self" do a = [1, 2, 3] - a.compact.should_not equal(a) + a.compact.should_not.equal?(a) end it "does not return subclass instance for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3, nil].compact.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3, nil].compact.should.instance_of?(Array) end end describe "Array#compact!" do it "removes all nil elements" do a = ['a', nil, 'b', false, 'c'] - a.compact!.should equal(a) + a.compact!.should.equal?(a) a.should == ["a", "b", false, "c"] a = [nil, 'a', 'b', false, 'c'] - a.compact!.should equal(a) + a.compact!.should.equal?(a) a.should == ["a", "b", false, "c"] a = ['a', 'b', false, 'c', nil] - a.compact!.should equal(a) + a.compact!.should.equal?(a) a.should == ["a", "b", false, "c"] end it "returns self if some nil elements are removed" do a = ['a', nil, 'b', false, 'c'] - a.compact!.should equal a + a.compact!.should.equal? a end it "returns nil if there are no nil elements to remove" do @@ -46,6 +46,6 @@ describe "Array#compact!" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.compact! }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.compact! }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/comparison_spec.rb b/spec/ruby/core/array/comparison_spec.rb index 5d1c3265f1..14e8931e5a 100644 --- a/spec/ruby/core/array/comparison_spec.rb +++ b/spec/ruby/core/array/comparison_spec.rb @@ -92,6 +92,6 @@ describe "Array#<=>" do end it "returns nil when the argument is not array-like" do - ([] <=> false).should be_nil + ([] <=> false).should == nil end end diff --git a/spec/ruby/core/array/concat_spec.rb b/spec/ruby/core/array/concat_spec.rb index f3cab9c17c..1e8d20c36c 100644 --- a/spec/ruby/core/array/concat_spec.rb +++ b/spec/ruby/core/array/concat_spec.rb @@ -4,12 +4,12 @@ require_relative 'fixtures/classes' describe "Array#concat" do it "returns the array itself" do ary = [1,2,3] - ary.concat([4,5,6]).equal?(ary).should be_true + ary.concat([4,5,6]).equal?(ary).should == true end it "appends the elements in the other array" do ary = [1, 2, 3] - ary.concat([9, 10, 11]).should equal(ary) + ary.concat([9, 10, 11]).should.equal?(ary) ary.should == [1, 2, 3, 9, 10, 11] ary.concat([]) ary.should == [1, 2, 3, 9, 10, 11] @@ -33,12 +33,12 @@ describe "Array#concat" do end it "raises a FrozenError when Array is frozen and modification occurs" do - -> { ArraySpecs.frozen_array.concat [1] }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.concat [1] }.should.raise(FrozenError) end # see [ruby-core:23666] it "raises a FrozenError when Array is frozen and no modification occurs" do - -> { ArraySpecs.frozen_array.concat([]) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.concat([]) }.should.raise(FrozenError) end it "appends elements to an Array with enough capacity that has been shifted" do @@ -68,7 +68,7 @@ describe "Array#concat" do it "returns self when given no arguments" do ary = [1, 2] - ary.concat.should equal(ary) + ary.concat.should.equal?(ary) ary.should == [1, 2] end end diff --git a/spec/ruby/core/array/constructor_spec.rb b/spec/ruby/core/array/constructor_spec.rb index 6f36074c45..c4398c535d 100644 --- a/spec/ruby/core/array/constructor_spec.rb +++ b/spec/ruby/core/array/constructor_spec.rb @@ -7,7 +7,7 @@ describe "Array.[]" do Array.[](5, true, nil, 'a', "Ruby", obj).should == [5, true, nil, "a", "Ruby", obj] a = ArraySpecs::MyArray.[](5, true, nil, 'a', "Ruby", obj) - a.should be_an_instance_of(ArraySpecs::MyArray) + a.should.instance_of?(ArraySpecs::MyArray) a.inspect.should == [5, true, nil, "a", "Ruby", obj].inspect end end @@ -18,7 +18,7 @@ describe "Array[]" do Array[5, true, nil, 'a', "Ruby", obj].should == Array.[](5, true, nil, "a", "Ruby", obj) a = ArraySpecs::MyArray[5, true, nil, 'a', "Ruby", obj] - a.should be_an_instance_of(ArraySpecs::MyArray) + a.should.instance_of?(ArraySpecs::MyArray) a.inspect.should == [5, true, nil, "a", "Ruby", obj].inspect end end diff --git a/spec/ruby/core/array/cycle_spec.rb b/spec/ruby/core/array/cycle_spec.rb index 7219b49883..29284257e9 100644 --- a/spec/ruby/core/array/cycle_spec.rb +++ b/spec/ruby/core/array/cycle_spec.rb @@ -10,17 +10,17 @@ describe "Array#cycle" do end it "does not yield and returns nil when the array is empty and passed value is an integer" do - [].cycle(6, &@prc).should be_nil + [].cycle(6, &@prc).should == nil ScratchPad.recorded.should == [] end it "does not yield and returns nil when the array is empty and passed value is nil" do - [].cycle(nil, &@prc).should be_nil + [].cycle(nil, &@prc).should == nil ScratchPad.recorded.should == [] end it "does not yield and returns nil when passed 0" do - @array.cycle(0, &@prc).should be_nil + @array.cycle(0, &@prc).should == nil ScratchPad.recorded.should == [] end @@ -48,13 +48,13 @@ describe "Array#cycle" do it "does not rescue StopIteration when not passed a count" do -> do @array.cycle { raise StopIteration } - end.should raise_error(StopIteration) + end.should.raise(StopIteration) end it "does not rescue StopIteration when passed a count" do -> do @array.cycle(3) { raise StopIteration } - end.should raise_error(StopIteration) + end.should.raise(StopIteration) end it "iterates the array Integer(count) times when passed a Float count" do @@ -74,23 +74,23 @@ describe "Array#cycle" do count = mock("cycle count 2") count.should_receive(:to_int).and_return("2") - -> { @array.cycle(count, &@prc) }.should raise_error(TypeError) + -> { @array.cycle(count, &@prc) }.should.raise(TypeError) end it "raises a TypeError if passed a String" do - -> { @array.cycle("4") { } }.should raise_error(TypeError) + -> { @array.cycle("4") { } }.should.raise(TypeError) end it "raises a TypeError if passed an Object" do - -> { @array.cycle(mock("cycle count")) { } }.should raise_error(TypeError) + -> { @array.cycle(mock("cycle count")) { } }.should.raise(TypeError) end it "raises a TypeError if passed true" do - -> { @array.cycle(true) { } }.should raise_error(TypeError) + -> { @array.cycle(true) { } }.should.raise(TypeError) end it "raises a TypeError if passed false" do - -> { @array.cycle(false) { } }.should raise_error(TypeError) + -> { @array.cycle(false) { } }.should.raise(TypeError) end before :all do diff --git a/spec/ruby/core/array/deconstruct_spec.rb b/spec/ruby/core/array/deconstruct_spec.rb index ad67abe47b..11bb8e72c4 100644 --- a/spec/ruby/core/array/deconstruct_spec.rb +++ b/spec/ruby/core/array/deconstruct_spec.rb @@ -4,6 +4,6 @@ describe "Array#deconstruct" do it "returns self" do array = [1] - array.deconstruct.should equal array + array.deconstruct.should.equal? array end end diff --git a/spec/ruby/core/array/delete_at_spec.rb b/spec/ruby/core/array/delete_at_spec.rb index 80ec643702..1e298b6730 100644 --- a/spec/ruby/core/array/delete_at_spec.rb +++ b/spec/ruby/core/array/delete_at_spec.rb @@ -36,6 +36,6 @@ describe "Array#delete_at" do end it "raises a FrozenError on a frozen array" do - -> { [1,2,3].freeze.delete_at(0) }.should raise_error(FrozenError) + -> { [1,2,3].freeze.delete_at(0) }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/delete_if_spec.rb b/spec/ruby/core/array/delete_if_spec.rb index 10972eee0e..701a612395 100644 --- a/spec/ruby/core/array/delete_if_spec.rb +++ b/spec/ruby/core/array/delete_if_spec.rb @@ -17,7 +17,7 @@ describe "Array#delete_if" do end it "returns self" do - @a.delete_if{ true }.equal?(@a).should be_true + @a.delete_if{ true }.equal?(@a).should == true end it_behaves_like :enumeratorize, :delete_if @@ -25,27 +25,27 @@ describe "Array#delete_if" do it "returns self when called on an Array emptied with #shift" do array = [1] array.shift - array.delete_if { |x| true }.should equal(array) + array.delete_if { |x| true }.should.equal?(array) end it "returns an Enumerator if no block given, and the enumerator can modify the original array" do enum = @a.delete_if - enum.should be_an_instance_of(Enumerator) - @a.should_not be_empty + enum.should.instance_of?(Enumerator) + @a.should_not.empty? enum.each { true } - @a.should be_empty + @a.should.empty? end it "returns an Enumerator if no block given, and the array is frozen" do - @a.freeze.delete_if.should be_an_instance_of(Enumerator) + @a.freeze.delete_if.should.instance_of?(Enumerator) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.delete_if {} }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.delete_if {} }.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.delete_if {} }.should.raise(FrozenError) end it "does not truncate the array is the block raises an exception" do diff --git a/spec/ruby/core/array/delete_spec.rb b/spec/ruby/core/array/delete_spec.rb index dddbbe6bd3..0d80b2839d 100644 --- a/spec/ruby/core/array/delete_spec.rb +++ b/spec/ruby/core/array/delete_spec.rb @@ -41,6 +41,6 @@ describe "Array#delete" do end it "raises a FrozenError on a frozen array" do - -> { [1, 2, 3].freeze.delete(1) }.should raise_error(FrozenError) + -> { [1, 2, 3].freeze.delete(1) }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/difference_spec.rb b/spec/ruby/core/array/difference_spec.rb index 9f7d4c4a1a..63e32feca0 100644 --- a/spec/ruby/core/array/difference_spec.rb +++ b/spec/ruby/core/array/difference_spec.rb @@ -8,11 +8,11 @@ describe "Array#difference" do it "returns a copy when called without any parameter" do x = [1, 2, 3, 2] x.difference.should == x - x.difference.should_not equal x + x.difference.should_not.equal? x end it "does not return subclass instances for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].difference.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].difference.should.instance_of?(Array) end it "accepts multiple arguments" do diff --git a/spec/ruby/core/array/dig_spec.rb b/spec/ruby/core/array/dig_spec.rb index f2d8ff47fd..4166ff9f1f 100644 --- a/spec/ruby/core/array/dig_spec.rb +++ b/spec/ruby/core/array/dig_spec.rb @@ -4,7 +4,7 @@ describe "Array#dig" do it "returns #at with one arg" do ['a'].dig(0).should == 'a' - ['a'].dig(1).should be_nil + ['a'].dig(1).should == nil end it "recurses array elements" do @@ -22,20 +22,20 @@ describe "Array#dig" do it "raises a TypeError for a non-numeric index" do -> { ['a'].dig(:first) - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "raises a TypeError if any intermediate step does not respond to #dig" do a = [1, 2] -> { a.dig(0, 1) - }.should raise_error(TypeError) + }.should.raise(TypeError) end it "raises an ArgumentError if no arguments provided" do -> { [10].dig() - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "returns nil if any intermediate step is nil" do diff --git a/spec/ruby/core/array/drop_spec.rb b/spec/ruby/core/array/drop_spec.rb index 0ea748e47d..c0e1c9edce 100644 --- a/spec/ruby/core/array/drop_spec.rb +++ b/spec/ruby/core/array/drop_spec.rb @@ -7,7 +7,7 @@ describe "Array#drop" do end it "raises an ArgumentError if the number of elements specified is negative" do - -> { [1, 2].drop(-3) }.should raise_error(ArgumentError) + -> { [1, 2].drop(-3) }.should.raise(ArgumentError) end it "returns an empty Array if all elements are dropped" do @@ -40,17 +40,17 @@ describe "Array#drop" do end it "raises a TypeError when the passed argument can't be coerced to Integer" do - -> { [1, 2].drop("cat") }.should raise_error(TypeError) + -> { [1, 2].drop("cat") }.should.raise(TypeError) end it "raises a TypeError when the passed argument isn't an integer and #to_int returns non-Integer" do obj = mock("to_int") obj.should_receive(:to_int).and_return("cat") - -> { [1, 2].drop(obj) }.should raise_error(TypeError) + -> { [1, 2].drop(obj) }.should.raise(TypeError) end it 'returns a Array instance for Array subclasses' do - ArraySpecs::MyArray[1, 2, 3, 4, 5].drop(1).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3, 4, 5].drop(1).should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/drop_while_spec.rb b/spec/ruby/core/array/drop_while_spec.rb index bd46e8b882..4fead3ff06 100644 --- a/spec/ruby/core/array/drop_while_spec.rb +++ b/spec/ruby/core/array/drop_while_spec.rb @@ -19,6 +19,6 @@ describe "Array#drop_while" do end it 'returns a Array instance for Array subclasses' do - ArraySpecs::MyArray[1, 2, 3, 4, 5].drop_while { |n| n < 4 }.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3, 4, 5].drop_while { |n| n < 4 }.should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/dup_spec.rb b/spec/ruby/core/array/dup_spec.rb index 17f467d5fc..f14aeca3b5 100644 --- a/spec/ruby/core/array/dup_spec.rb +++ b/spec/ruby/core/array/dup_spec.rb @@ -12,8 +12,8 @@ describe "Array#dup" do aa = a.dup bb = b.dup - aa.frozen?.should be_false - bb.frozen?.should be_false + aa.frozen?.should == false + bb.frozen?.should == false end it "does not copy singleton methods" do @@ -23,9 +23,9 @@ describe "Array#dup" do aa = a.dup bb = b.dup - a.respond_to?(:a_singleton_method).should be_true - b.respond_to?(:a_singleton_method).should be_false - aa.respond_to?(:a_singleton_method).should be_false - bb.respond_to?(:a_singleton_method).should be_false + a.respond_to?(:a_singleton_method).should == true + b.respond_to?(:a_singleton_method).should == false + aa.respond_to?(:a_singleton_method).should == false + bb.respond_to?(:a_singleton_method).should == false end end diff --git a/spec/ruby/core/array/each_index_spec.rb b/spec/ruby/core/array/each_index_spec.rb index 3a4bca9251..b238a89d8a 100644 --- a/spec/ruby/core/array/each_index_spec.rb +++ b/spec/ruby/core/array/each_index_spec.rb @@ -20,7 +20,7 @@ describe "Array#each_index" do it "returns self" do a = [:a, :b, :c] - a.each_index { |i| }.should equal(a) + a.each_index { |i| }.should.equal?(a) end it "is not confused by removing elements from the front" do diff --git a/spec/ruby/core/array/each_spec.rb b/spec/ruby/core/array/each_spec.rb index f4b5b758d0..73a4c36b17 100644 --- a/spec/ruby/core/array/each_spec.rb +++ b/spec/ruby/core/array/each_spec.rb @@ -13,7 +13,7 @@ describe "Array#each" do it "yields each element to the block" do a = [] x = [1, 2, 3] - x.each { |item| a << item }.should equal(x) + x.each { |item| a << item }.should.equal?(x) a.should == [1, 2, 3] end diff --git a/spec/ruby/core/array/element_reference_spec.rb b/spec/ruby/core/array/element_reference_spec.rb index 31e5578a09..eb41a9e199 100644 --- a/spec/ruby/core/array/element_reference_spec.rb +++ b/spec/ruby/core/array/element_reference_spec.rb @@ -39,12 +39,12 @@ describe "Array.[]" do end it "returns an instance of the subclass" do - ArraySpecs::MyArray[1, 2, 3].should be_an_instance_of(ArraySpecs::MyArray) + ArraySpecs::MyArray[1, 2, 3].should.instance_of?(ArraySpecs::MyArray) end it "does not call #initialize on the subclass instance" do ArraySpecs::MyArray[1, 2, 3].should == [1, 2, 3] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end end end diff --git a/spec/ruby/core/array/element_set_spec.rb b/spec/ruby/core/array/element_set_spec.rb index df5ca9582e..671e4338de 100644 --- a/spec/ruby/core/array/element_set_spec.rb +++ b/spec/ruby/core/array/element_set_spec.rb @@ -95,8 +95,8 @@ describe "Array#[]=" do it "checks frozen before attempting to coerce arguments" do a = [1,2,3,4].freeze - -> {a[:foo] = 1}.should raise_error(FrozenError) - -> {a[:foo, :bar] = 1}.should raise_error(FrozenError) + -> {a[:foo] = 1}.should.raise(FrozenError) + -> {a[:foo, :bar] = 1}.should.raise(FrozenError) end it "sets elements in the range arguments when passed ranges" do @@ -197,25 +197,25 @@ describe "Array#[]=" do a[to .. from] = ["x"] a.should == [1, "a", "b", "x", "c", 4] - -> { a["a" .. "b"] = [] }.should raise_error(TypeError) - -> { a[from .. "b"] = [] }.should raise_error(TypeError) + -> { a["a" .. "b"] = [] }.should.raise(TypeError) + -> { a[from .. "b"] = [] }.should.raise(TypeError) end it "raises an IndexError when passed indexes out of bounds" do a = [1, 2, 3, 4] - -> { a[-5] = "" }.should raise_error(IndexError) - -> { a[-5, -1] = "" }.should raise_error(IndexError) - -> { a[-5, 0] = "" }.should raise_error(IndexError) - -> { a[-5, 1] = "" }.should raise_error(IndexError) - -> { a[-5, 2] = "" }.should raise_error(IndexError) - -> { a[-5, 10] = "" }.should raise_error(IndexError) - - -> { a[-5..-5] = "" }.should raise_error(RangeError) - -> { a[-5...-5] = "" }.should raise_error(RangeError) - -> { a[-5..-4] = "" }.should raise_error(RangeError) - -> { a[-5...-4] = "" }.should raise_error(RangeError) - -> { a[-5..10] = "" }.should raise_error(RangeError) - -> { a[-5...10] = "" }.should raise_error(RangeError) + -> { a[-5] = "" }.should.raise(IndexError) + -> { a[-5, -1] = "" }.should.raise(IndexError) + -> { a[-5, 0] = "" }.should.raise(IndexError) + -> { a[-5, 1] = "" }.should.raise(IndexError) + -> { a[-5, 2] = "" }.should.raise(IndexError) + -> { a[-5, 10] = "" }.should.raise(IndexError) + + -> { a[-5..-5] = "" }.should.raise(RangeError) + -> { a[-5...-5] = "" }.should.raise(RangeError) + -> { a[-5..-4] = "" }.should.raise(RangeError) + -> { a[-5...-4] = "" }.should.raise(RangeError) + -> { a[-5..10] = "" }.should.raise(RangeError) + -> { a[-5...10] = "" }.should.raise(RangeError) # ok a[0..-9] = [1] @@ -239,7 +239,7 @@ describe "Array#[]=" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array[0, 0] = [] }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array[0, 0] = [] }.should.raise(FrozenError) end end @@ -349,12 +349,12 @@ describe "Array#[]= with [index, count]" do it "raises an IndexError when passed start and negative length" do a = [1, 2, 3, 4] - -> { a[-2, -1] = "" }.should raise_error(IndexError) - -> { a[0, -1] = "" }.should raise_error(IndexError) - -> { a[2, -1] = "" }.should raise_error(IndexError) - -> { a[4, -1] = "" }.should raise_error(IndexError) - -> { a[10, -1] = "" }.should raise_error(IndexError) - -> { [1, 2, 3, 4, 5][2, -1] = [7, 8] }.should raise_error(IndexError) + -> { a[-2, -1] = "" }.should.raise(IndexError) + -> { a[0, -1] = "" }.should.raise(IndexError) + -> { a[2, -1] = "" }.should.raise(IndexError) + -> { a[4, -1] = "" }.should.raise(IndexError) + -> { a[10, -1] = "" }.should.raise(IndexError) + -> { [1, 2, 3, 4, 5][2, -1] = [7, 8] }.should.raise(IndexError) end end diff --git a/spec/ruby/core/array/eql_spec.rb b/spec/ruby/core/array/eql_spec.rb index 8565b94c60..9a7447c2e8 100644 --- a/spec/ruby/core/array/eql_spec.rb +++ b/spec/ruby/core/array/eql_spec.rb @@ -6,7 +6,7 @@ describe "Array#eql?" do it_behaves_like :array_eql, :eql? it "returns false if any corresponding elements are not #eql?" do - [1, 2, 3, 4].should_not eql([1, 2, 3, 4.0]) + [1, 2, 3, 4].should_not.eql?([1, 2, 3, 4.0]) end it "returns false if other is not a kind of Array" do @@ -14,6 +14,6 @@ describe "Array#eql?" do obj.should_not_receive(:to_ary) obj.should_not_receive(:eql?) - [1, 2, 3].should_not eql(obj) + [1, 2, 3].should_not.eql?(obj) end end diff --git a/spec/ruby/core/array/equal_value_spec.rb b/spec/ruby/core/array/equal_value_spec.rb index a82e07b218..4f7c0ce5e3 100644 --- a/spec/ruby/core/array/equal_value_spec.rb +++ b/spec/ruby/core/array/equal_value_spec.rb @@ -10,17 +10,17 @@ describe "Array#==" do obj.should_receive(:respond_to?).at_least(1).with(:to_ary).and_return(true) obj.should_receive(:==).with([1]).at_least(1).and_return(true) - ([1] == obj).should be_true - ([[1]] == [obj]).should be_true - ([[[1], 3], 2] == [[obj, 3], 2]).should be_true + ([1] == obj).should == true + ([[1]] == [obj]).should == true + ([[[1], 3], 2] == [[obj, 3], 2]).should == true # recursive arrays arr1 = [[1]] arr1 << arr1 arr2 = [obj] arr2 << arr2 - (arr1 == arr2).should be_true - (arr2 == arr1).should be_true + (arr1 == arr2).should == true + (arr2 == arr1).should == true end it "returns false if any corresponding elements are not #==" do diff --git a/spec/ruby/core/array/fetch_spec.rb b/spec/ruby/core/array/fetch_spec.rb index b81c0b48d7..ee94cfcbb2 100644 --- a/spec/ruby/core/array/fetch_spec.rb +++ b/spec/ruby/core/array/fetch_spec.rb @@ -12,9 +12,9 @@ describe "Array#fetch" do end it "raises an IndexError if there is no element at index" do - -> { [1, 2, 3].fetch(3) }.should raise_error(IndexError) - -> { [1, 2, 3].fetch(-4) }.should raise_error(IndexError) - -> { [].fetch(0) }.should raise_error(IndexError) + -> { [1, 2, 3].fetch(3) }.should.raise(IndexError, "index 3 outside of array bounds: -3...3") + -> { [1, 2, 3].fetch(-4) }.should.raise(IndexError, "index -4 outside of array bounds: -3...3") + -> { [].fetch(0) }.should.raise(IndexError, "index 0 outside of array bounds: 0...0") end it "returns default if there is no element at index if passed a default value" do @@ -33,7 +33,7 @@ describe "Array#fetch" do o = mock('5') def o.to_int(); 5; end - [1, 2, 3].fetch(o) { |i| i }.should equal(o) + [1, 2, 3].fetch(o) { |i| i }.should.equal?(o) end it "gives precedence to the default block over the default argument" do @@ -50,6 +50,6 @@ describe "Array#fetch" do end it "raises a TypeError when the passed argument can't be coerced to Integer" do - -> { [].fetch("cat") }.should raise_error(TypeError) + -> { [].fetch("cat") }.should.raise(TypeError, "no implicit conversion of String into Integer") end end diff --git a/spec/ruby/core/array/fetch_values_spec.rb b/spec/ruby/core/array/fetch_values_spec.rb index 559b6c2b2f..237d6ad7f7 100644 --- a/spec/ruby/core/array/fetch_values_spec.rb +++ b/spec/ruby/core/array/fetch_values_spec.rb @@ -11,6 +11,7 @@ describe "Array#fetch_values" do it "returns the values for indexes" do @array.fetch_values(0).should == [:a] @array.fetch_values(0, 2).should == [:a, :c] + @array.fetch_values(-1).should == [:c] end it "returns the values for indexes ordered in the order of the requested indexes" do @@ -20,7 +21,7 @@ describe "Array#fetch_values" do describe "with unmatched indexes" do it "raises a index error if no block is provided" do - -> { @array.fetch_values(0, 1, 44) }.should raise_error(IndexError) + -> { @array.fetch_values(0, 1, 44) }.should.raise(IndexError, "index 44 outside of array bounds: -3...3") end it "returns the default value from block" do @@ -41,8 +42,14 @@ describe "Array#fetch_values" do @array.fetch_values(obj).should == [:c] end + it "does not support a Range object as argument" do + -> { + @array.fetch_values(1..2) + }.should.raise(TypeError, "no implicit conversion of Range into Integer") + end + it "raises a TypeError when the passed argument can't be coerced to Integer" do - -> { [].fetch_values("cat") }.should raise_error(TypeError) + -> { [].fetch_values("cat") }.should.raise(TypeError, "no implicit conversion of String into Integer") end end end diff --git a/spec/ruby/core/array/fill_spec.rb b/spec/ruby/core/array/fill_spec.rb index 2c3b5d9e84..e4d51bd998 100644 --- a/spec/ruby/core/array/fill_spec.rb +++ b/spec/ruby/core/array/fill_spec.rb @@ -10,7 +10,7 @@ describe "Array#fill" do it "returns self" do ary = [1, 2, 3] - ary.fill(:a).should equal(ary) + ary.fill(:a).should.equal?(ary) end it "is destructive" do @@ -25,10 +25,10 @@ describe "Array#fill" do ary.fill(str).should == [str, str, str, str] str << "y" ary.should == [str, str, str, str] - ary[0].should equal(str) - ary[1].should equal(str) - ary[2].should equal(str) - ary[3].should equal(str) + ary[0].should.equal?(str) + ary[1].should.equal?(str) + ary[2].should.equal?(str) + ary[3].should.equal?(str) end it "replaces all elements in the array with the filler if not given a index nor a length" do @@ -44,29 +44,29 @@ describe "Array#fill" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.fill('x') }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.fill('x') }.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.fill('x') }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.fill('x') }.should.raise(FrozenError) end it "raises an ArgumentError if 4 or more arguments are passed when no block given" do [].fill('a').should == [] [].fill('a', 1).should == [] [].fill('a', 1, 2).should == [nil, 'a', 'a'] - -> { [].fill('a', 1, 2, true) }.should raise_error(ArgumentError) + -> { [].fill('a', 1, 2, true) }.should.raise(ArgumentError) end it "raises an ArgumentError if no argument passed and no block given" do - -> { [].fill }.should raise_error(ArgumentError) + -> { [].fill }.should.raise(ArgumentError) end it "raises an ArgumentError if 3 or more arguments are passed when a block given" do [].fill() {|i|}.should == [] [].fill(1) {|i|}.should == [] [].fill(1, 2) {|i|}.should == [nil, nil, nil] - -> { [].fill(1, 2, true) {|i|} }.should raise_error(ArgumentError) + -> { [].fill(1, 2, true) {|i|} }.should.raise(ArgumentError) end it "does not truncate the array is the block raises an exception" do @@ -237,24 +237,24 @@ describe "Array#fill with (filler, index, length)" do end it "raises a TypeError if the index is not numeric" do - -> { [].fill 'a', true }.should raise_error(TypeError) + -> { [].fill 'a', true }.should.raise(TypeError) obj = mock('nonnumeric') - -> { [].fill('a', obj) }.should raise_error(TypeError) + -> { [].fill('a', obj) }.should.raise(TypeError) end it "raises a TypeError when the length is not numeric" do - -> { [1, 2, 3].fill("x", 1, "foo") }.should raise_error(TypeError, /no implicit conversion of String into Integer/) - -> { [1, 2, 3].fill("x", 1, :"foo") }.should raise_error(TypeError, /no implicit conversion of Symbol into Integer/) - -> { [1, 2, 3].fill("x", 1, Object.new) }.should raise_error(TypeError, /no implicit conversion of Object into Integer/) + -> { [1, 2, 3].fill("x", 1, "foo") }.should.raise(TypeError, /no implicit conversion of String into Integer/) + -> { [1, 2, 3].fill("x", 1, :"foo") }.should.raise(TypeError, /no implicit conversion of Symbol into Integer/) + -> { [1, 2, 3].fill("x", 1, Object.new) }.should.raise(TypeError, /no implicit conversion of Object into Integer/) end not_supported_on :opal do it "raises an ArgumentError or RangeError for too-large sizes" do error_types = [RangeError, ArgumentError] arr = [1, 2, 3] - -> { arr.fill(10, 1, fixnum_max) }.should raise_error { |err| error_types.should include(err.class) } - -> { arr.fill(10, 1, bignum_value) }.should raise_error(RangeError) + -> { arr.fill(10, 1, fixnum_max) }.should.raise { |err| error_types.should.include?(err.class) } + -> { arr.fill(10, 1, bignum_value) }.should.raise(RangeError) end end end @@ -284,7 +284,7 @@ describe "Array#fill with (filler, range)" do end it "raises a TypeError with range and length argument" do - -> { [].fill('x', 0 .. 2, 5) }.should raise_error(TypeError) + -> { [].fill('x', 0 .. 2, 5) }.should.raise(TypeError) end it "replaces elements between the (-m)th to the last and the (n+1)th from the first if given an range m..n where m < 0 and n >= 0" do @@ -336,13 +336,13 @@ describe "Array#fill with (filler, range)" do end it "raises an exception if some of the given range lies before the first of the array" do - -> { [1, 2, 3].fill('x', -5..-3) }.should raise_error(RangeError) - -> { [1, 2, 3].fill('x', -5...-3) }.should raise_error(RangeError) - -> { [1, 2, 3].fill('x', -5..-4) }.should raise_error(RangeError) + -> { [1, 2, 3].fill('x', -5..-3) }.should.raise(RangeError) + -> { [1, 2, 3].fill('x', -5...-3) }.should.raise(RangeError) + -> { [1, 2, 3].fill('x', -5..-4) }.should.raise(RangeError) - -> { [1, 2, 3].fill(-5..-3, &@never_passed) }.should raise_error(RangeError) - -> { [1, 2, 3].fill(-5...-3, &@never_passed) }.should raise_error(RangeError) - -> { [1, 2, 3].fill(-5..-4, &@never_passed) }.should raise_error(RangeError) + -> { [1, 2, 3].fill(-5..-3, &@never_passed) }.should.raise(RangeError) + -> { [1, 2, 3].fill(-5...-3, &@never_passed) }.should.raise(RangeError) + -> { [1, 2, 3].fill(-5..-4, &@never_passed) }.should.raise(RangeError) end it "tries to convert the start and end of the passed range to Integers using #to_int" do @@ -357,7 +357,7 @@ describe "Array#fill with (filler, range)" do it "raises a TypeError if the start or end of the passed range is not numeric" do obj = mock('nonnumeric') def obj.<=>(rhs); rhs == self ? 0 : nil end - -> { [].fill('a', obj..obj) }.should raise_error(TypeError) + -> { [].fill('a', obj..obj) }.should.raise(TypeError) end it "works with endless ranges" do diff --git a/spec/ruby/core/array/filter_spec.rb b/spec/ruby/core/array/filter_spec.rb index 156ad14f9c..7807c3886d 100644 --- a/spec/ruby/core/array/filter_spec.rb +++ b/spec/ruby/core/array/filter_spec.rb @@ -7,7 +7,7 @@ end describe "Array#filter!" do it "returns nil if no changes were made in the array" do - [1, 2, 3].filter! { true }.should be_nil + [1, 2, 3].filter! { true }.should == nil end it_behaves_like :keep_if, :filter! diff --git a/spec/ruby/core/array/first_spec.rb b/spec/ruby/core/array/first_spec.rb index 66eeba6565..2c343ac8f6 100644 --- a/spec/ruby/core/array/first_spec.rb +++ b/spec/ruby/core/array/first_spec.rb @@ -30,11 +30,11 @@ describe "Array#first" do end it "raises an ArgumentError when count is negative" do - -> { [1, 2].first(-1) }.should raise_error(ArgumentError) + -> { [1, 2].first(-1) }.should.raise(ArgumentError) end it "raises a RangeError when count is a Bignum" do - -> { [].first(bignum_value) }.should raise_error(RangeError) + -> { [].first(bignum_value) }.should.raise(RangeError) end it "returns the entire array when count > length" do @@ -53,10 +53,10 @@ describe "Array#first" do it "properly handles recursive arrays" do empty = ArraySpecs.empty_recursive_array - empty.first.should equal(empty) + empty.first.should.equal?(empty) ary = ArraySpecs.head_recursive_array - ary.first.should equal(ary) + ary.first.should.equal?(ary) end it "tries to convert the passed argument to an Integer using #to_int" do @@ -66,19 +66,19 @@ describe "Array#first" do end it "raises a TypeError if the passed argument is not numeric" do - -> { [1,2].first(nil) }.should raise_error(TypeError) - -> { [1,2].first("a") }.should raise_error(TypeError) + -> { [1,2].first(nil) }.should.raise(TypeError) + -> { [1,2].first("a") }.should.raise(TypeError) obj = mock("nonnumeric") - -> { [1,2].first(obj) }.should raise_error(TypeError) + -> { [1,2].first(obj) }.should.raise(TypeError) end it "does not return subclass instance when passed count on Array subclasses" do - ArraySpecs::MyArray[].first(0).should be_an_instance_of(Array) - ArraySpecs::MyArray[].first(2).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].first(0).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].first(1).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].first(2).should be_an_instance_of(Array) + ArraySpecs::MyArray[].first(0).should.instance_of?(Array) + ArraySpecs::MyArray[].first(2).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].first(0).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].first(1).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].first(2).should.instance_of?(Array) end it "is not destructive" do diff --git a/spec/ruby/core/array/flatten_spec.rb b/spec/ruby/core/array/flatten_spec.rb index 8c97000c79..272406b8f9 100644 --- a/spec/ruby/core/array/flatten_spec.rb +++ b/spec/ruby/core/array/flatten_spec.rb @@ -13,7 +13,7 @@ describe "Array#flatten" do it "returns dup when the level of recursion is 0" do a = [ 1, 2, [3, [4, 5] ] ] a.flatten(0).should == a - a.flatten(0).should_not equal(a) + a.flatten(0).should_not.equal?(a) end it "ignores negative levels" do @@ -30,7 +30,7 @@ describe "Array#flatten" do it "raises a TypeError when the passed Object can't be converted to an Integer" do obj = mock("Not converted") - -> { [ 1, 2, [3, [4, 5] ] ].flatten(obj) }.should raise_error(TypeError) + -> { [ 1, 2, [3, [4, 5] ] ].flatten(obj) }.should.raise(TypeError) end it "does not call flatten on elements" do @@ -46,13 +46,13 @@ describe "Array#flatten" do it "raises an ArgumentError on recursive arrays" do x = [] x << x - -> { x.flatten }.should raise_error(ArgumentError) + -> { x.flatten }.should.raise(ArgumentError) x = [] y = [] x << y y << x - -> { x.flatten }.should raise_error(ArgumentError) + -> { x.flatten }.should.raise(ArgumentError) end it "flattens any element which responds to #to_ary, using the return value of said method" do @@ -76,11 +76,11 @@ describe "Array#flatten" do end it "returns Array instance for Array subclasses" do - ArraySpecs::MyArray[].flatten.should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].flatten.should be_an_instance_of(Array) - ArraySpecs::MyArray[1, [2], 3].flatten.should be_an_instance_of(Array) + ArraySpecs::MyArray[].flatten.should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].flatten.should.instance_of?(Array) + ArraySpecs::MyArray[1, [2], 3].flatten.should.instance_of?(Array) ArraySpecs::MyArray[1, [2, 3], 4].flatten.should == [1, 2, 3, 4] - [ArraySpecs::MyArray[1, 2, 3]].flatten.should be_an_instance_of(Array) + [ArraySpecs::MyArray[1, 2, 3]].flatten.should.instance_of?(Array) end it "is not destructive" do @@ -106,7 +106,7 @@ describe "Array#flatten" do it "raises a TypeError if #to_ary does not return an Array" do @obj.should_receive(:to_ary).and_return(1) - -> { [@obj].flatten }.should raise_error(TypeError) + -> { [@obj].flatten }.should.raise(TypeError) end it "calls respond_to_missing?(:to_ary, true) to try coercing" do @@ -125,7 +125,7 @@ describe "Array#flatten" do it "calls #to_ary if not defined when #respond_to_missing? returns true" do def @obj.respond_to_missing?(name, priv) ScratchPad << name; true end - -> { [@obj].flatten }.should raise_error(NoMethodError) + -> { [@obj].flatten }.should.raise(NoMethodError) ScratchPad.recorded.should == [:to_ary] end @@ -168,7 +168,7 @@ describe "Array#flatten!" do it "returns self if made some modifications" do a = [[[1, [2, 3]],[2, 3, [4, [4, [5, 5]], [1, 2, 3]]], [4]], []] - a.flatten!.should equal(a) + a.flatten!.should.equal?(a) end it "returns nil if no modifications took place" do @@ -208,7 +208,7 @@ describe "Array#flatten!" do it "raises a TypeError when the passed Object can't be converted to an Integer" do obj = mock("Not converted") - -> { [ 1, 2, [3, [4, 5] ] ].flatten!(obj) }.should raise_error(TypeError) + -> { [ 1, 2, [3, [4, 5] ] ].flatten!(obj) }.should.raise(TypeError) end it "does not call flatten! on elements" do @@ -224,13 +224,13 @@ describe "Array#flatten!" do it "raises an ArgumentError on recursive arrays" do x = [] x << x - -> { x.flatten! }.should raise_error(ArgumentError) + -> { x.flatten! }.should.raise(ArgumentError) x = [] y = [] x << y y << x - -> { x.flatten! }.should raise_error(ArgumentError) + -> { x.flatten! }.should.raise(ArgumentError) end it "flattens any elements which responds to #to_ary, using the return value of said method" do @@ -248,19 +248,19 @@ describe "Array#flatten!" do ary = [ArraySpecs::MyArray[1, 2, 3]] ary.flatten! - ary.should be_an_instance_of(Array) + ary.should.instance_of?(Array) ary.should == [1, 2, 3] end it "raises a FrozenError on frozen arrays when the array is modified" do nested_ary = [1, 2, []] nested_ary.freeze - -> { nested_ary.flatten! }.should raise_error(FrozenError) + -> { nested_ary.flatten! }.should.raise(FrozenError) end # see [ruby-core:23663] it "raises a FrozenError on frozen arrays when the array would not be modified" do - -> { ArraySpecs.frozen_array.flatten! }.should raise_error(FrozenError) - -> { ArraySpecs.empty_frozen_array.flatten! }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.flatten! }.should.raise(FrozenError) + -> { ArraySpecs.empty_frozen_array.flatten! }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/hash_spec.rb b/spec/ruby/core/array/hash_spec.rb index f3bcc83fce..3b7b6d5bed 100644 --- a/spec/ruby/core/array/hash_spec.rb +++ b/spec/ruby/core/array/hash_spec.rb @@ -7,16 +7,16 @@ describe "Array#hash" do [[], [1, 2, 3]].each do |ary| ary.hash.should == ary.dup.hash - ary.hash.should be_an_instance_of(Integer) + ary.hash.should.instance_of?(Integer) end end it "properly handles recursive arrays" do empty = ArraySpecs.empty_recursive_array - -> { empty.hash }.should_not raise_error + -> { empty.hash }.should_not.raise array = ArraySpecs.recursive_array - -> { array.hash }.should_not raise_error + -> { array.hash }.should_not.raise end it "returns the same hash for equal recursive arrays" do @@ -74,7 +74,7 @@ describe "Array#hash" do a.fill 'a', 0..3 b = %w|a a a a| a.hash.should == b.hash - a.should eql(b) + a.should.eql?(b) end it "produces different hashes for nested arrays with different values and empty terminator" do diff --git a/spec/ruby/core/array/initialize_spec.rb b/spec/ruby/core/array/initialize_spec.rb index b9fa77b16e..19ee37825e 100644 --- a/spec/ruby/core/array/initialize_spec.rb +++ b/spec/ruby/core/array/initialize_spec.rb @@ -7,7 +7,7 @@ describe "Array#initialize" do end it "is private" do - Array.should have_private_instance_method("initialize") + Array.private_instance_methods(false).should.include?(:initialize) end it "is called on subclasses" do @@ -19,26 +19,26 @@ describe "Array#initialize" do it "preserves the object's identity even when changing its value" do a = [1, 2, 3] - a.send(:initialize).should equal(a) + a.send(:initialize).should.equal?(a) a.should_not == [1, 2, 3] end it "raises an ArgumentError if passed 3 or more arguments" do -> do [1, 2].send :initialize, 1, 'x', true - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) -> do [1, 2].send(:initialize, 1, 'x', true) {} - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end it "raises a FrozenError on frozen arrays" do -> do ArraySpecs.frozen_array.send :initialize - end.should raise_error(FrozenError) + end.should.raise(FrozenError) -> do ArraySpecs.frozen_array.send :initialize, ArraySpecs.frozen_array - end.should raise_error(FrozenError) + end.should.raise(FrozenError) end it "calls #to_ary to convert the value to an array, even if it's private" do @@ -49,12 +49,12 @@ end describe "Array#initialize with no arguments" do it "makes the array empty" do - [1, 2, 3].send(:initialize).should be_empty + [1, 2, 3].send(:initialize).should.empty? end it "does not use the given block" do -> { - -> { [1, 2, 3].send(:initialize) { raise } }.should_not raise_error + -> { [1, 2, 3].send(:initialize) { raise } }.should_not.raise }.should complain(/#{__FILE__}:#{__LINE__-1}: warning: given block not used/, verbose: true) end end @@ -66,7 +66,7 @@ describe "Array#initialize with (array)" do end it "does not use the given block" do - ->{ [1, 2, 3].send(:initialize) { raise } }.should_not raise_error + ->{ [1, 2, 3].send(:initialize) { raise } }.should_not.raise end it "calls #to_ary to convert the value to an array" do @@ -83,7 +83,7 @@ describe "Array#initialize with (array)" do end it "raises a TypeError if an Array type argument and a default object" do - -> { [].send(:initialize, [1, 2], 1) }.should raise_error(TypeError) + -> { [].send(:initialize, [1, 2], 1) }.should.raise(TypeError) end end @@ -92,8 +92,8 @@ describe "Array#initialize with (size, object=nil)" do a = [] obj = [3] a.send(:initialize, 2, obj).should == [obj, obj] - a[0].should equal(obj) - a[1].should equal(obj) + a[0].should.equal?(obj) + a[1].should.equal?(obj) b = [] b.send(:initialize, 3, 14).should == [14, 14, 14] @@ -105,12 +105,12 @@ describe "Array#initialize with (size, object=nil)" do end it "raises an ArgumentError if size is negative" do - -> { [].send(:initialize, -1, :a) }.should raise_error(ArgumentError) - -> { [].send(:initialize, -1) }.should raise_error(ArgumentError) + -> { [].send(:initialize, -1, :a) }.should.raise(ArgumentError) + -> { [].send(:initialize, -1) }.should.raise(ArgumentError) end it "raises an ArgumentError if size is too large" do - -> { [].send(:initialize, fixnum_max+1) }.should raise_error(ArgumentError) + -> { [].send(:initialize, fixnum_max+1) }.should.raise(ArgumentError) end it "calls #to_int to convert the size argument to an Integer when object is given" do @@ -128,7 +128,7 @@ describe "Array#initialize with (size, object=nil)" do it "raises a TypeError if the size argument is not an Integer type" do obj = mock('nonnumeric') obj.stub!(:to_ary).and_return([1, 2]) - ->{ [].send(:initialize, obj, :a) }.should raise_error(TypeError) + ->{ [].send(:initialize, obj, :a) }.should.raise(TypeError) end it "yields the index of the element and sets the element to the value of the block" do diff --git a/spec/ruby/core/array/insert_spec.rb b/spec/ruby/core/array/insert_spec.rb index 9e1757f68b..38e132fd25 100644 --- a/spec/ruby/core/array/insert_spec.rb +++ b/spec/ruby/core/array/insert_spec.rb @@ -4,8 +4,8 @@ require_relative 'fixtures/classes' describe "Array#insert" do it "returns self" do ary = [] - ary.insert(0).should equal(ary) - ary.insert(0, :a).should equal(ary) + ary.insert(0).should.equal?(ary) + ary.insert(0, :a).should.equal?(ary) end it "inserts objects before the element at index for non-negative index" do @@ -46,8 +46,8 @@ describe "Array#insert" do end it "raises an IndexError if the negative index is out of bounds" do - -> { [].insert(-2, 1) }.should raise_error(IndexError) - -> { [1].insert(-3, 2) }.should raise_error(IndexError) + -> { [].insert(-2, 1) }.should.raise(IndexError) + -> { [1].insert(-3, 2) }.should.raise(IndexError) end it "does nothing of no object is passed" do @@ -64,15 +64,15 @@ describe "Array#insert" do end it "raises an ArgumentError if no argument passed" do - -> { [].insert() }.should raise_error(ArgumentError) + -> { [].insert() }.should.raise(ArgumentError) end it "raises a FrozenError on frozen arrays when the array is modified" do - -> { ArraySpecs.frozen_array.insert(0, 'x') }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.insert(0, 'x') }.should.raise(FrozenError) end # see [ruby-core:23666] it "raises a FrozenError on frozen arrays when the array would not be modified" do - -> { ArraySpecs.frozen_array.insert(0) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.insert(0) }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/intersect_spec.rb b/spec/ruby/core/array/intersect_spec.rb index 62ac157278..456aa26c6e 100644 --- a/spec/ruby/core/array/intersect_spec.rb +++ b/spec/ruby/core/array/intersect_spec.rb @@ -2,65 +2,63 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe 'Array#intersect?' do - ruby_version_is '3.1' do # https://bugs.ruby-lang.org/issues/15198 - describe 'when at least one element in two Arrays is the same' do - it 'returns true' do - [1, 2].intersect?([2, 3, 4]).should == true - [2, 3, 4].intersect?([1, 2]).should == true - end + describe 'when at least one element in two Arrays is the same' do + it 'returns true' do + [1, 2].intersect?([2, 3, 4]).should == true + [2, 3, 4].intersect?([1, 2]).should == true end + end - describe 'when there are no elements in common between two Arrays' do - it 'returns false' do - [0, 1, 2].intersect?([3, 4]).should == false - [3, 4].intersect?([0, 1, 2]).should == false - [3, 4].intersect?([]).should == false - [].intersect?([0, 1, 2]).should == false - end + describe 'when there are no elements in common between two Arrays' do + it 'returns false' do + [0, 1, 2].intersect?([3, 4]).should == false + [3, 4].intersect?([0, 1, 2]).should == false + [3, 4].intersect?([]).should == false + [].intersect?([0, 1, 2]).should == false end + end - it "tries to convert the passed argument to an Array using #to_ary" do - obj = mock('[1,2,3]') - obj.should_receive(:to_ary).and_return([1, 2, 3]) + it "tries to convert the passed argument to an Array using #to_ary" do + obj = mock('[1,2,3]') + obj.should_receive(:to_ary).and_return([1, 2, 3]) - [1, 2].intersect?(obj).should == true - end + [1, 2].intersect?(obj).should == true + end - it "determines equivalence between elements in the sense of eql?" do - obj1 = mock('1') - obj2 = mock('2') - obj1.stub!(:hash).and_return(0) - obj2.stub!(:hash).and_return(0) - obj1.stub!(:eql?).and_return(true) - obj2.stub!(:eql?).and_return(true) + it "determines equivalence between elements in the sense of eql?" do + obj1 = mock('1') + obj2 = mock('2') + obj1.stub!(:hash).and_return(0) + obj2.stub!(:hash).and_return(0) + obj1.stub!(:eql?).and_return(true) + obj2.stub!(:eql?).and_return(true) - [obj1].intersect?([obj2]).should == true + [obj1].intersect?([obj2]).should == true - obj1 = mock('3') - obj2 = mock('4') - obj1.stub!(:hash).and_return(0) - obj2.stub!(:hash).and_return(0) - obj1.stub!(:eql?).and_return(false) - obj2.stub!(:eql?).and_return(false) + obj1 = mock('3') + obj2 = mock('4') + obj1.stub!(:hash).and_return(0) + obj2.stub!(:hash).and_return(0) + obj1.stub!(:eql?).and_return(false) + obj2.stub!(:eql?).and_return(false) - [obj1].intersect?([obj2]).should == false - end + [obj1].intersect?([obj2]).should == false + end - it "does not call to_ary on array subclasses" do - [5, 6].intersect?(ArraySpecs::ToAryArray[1, 2, 5, 6]).should == true - end + it "does not call to_ary on array subclasses" do + [5, 6].intersect?(ArraySpecs::ToAryArray[1, 2, 5, 6]).should == true + end - it "properly handles an identical item even when its #eql? isn't reflexive" do - x = mock('x') - x.stub!(:hash).and_return(42) - x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI. + it "properly handles an identical item even when its #eql? isn't reflexive" do + x = mock('x') + x.stub!(:hash).and_return(42) + x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI. - [x].intersect?([x]).should == true - end + [x].intersect?([x]).should == true + end - it "has semantic of !(a & b).empty?" do - [].intersect?([]).should == false - [nil].intersect?([nil]).should == true - end + it "has semantic of !(a & b).empty?" do + [].intersect?([]).should == false + [nil].intersect?([nil]).should == true end end diff --git a/spec/ruby/core/array/join_spec.rb b/spec/ruby/core/array/join_spec.rb index e78ea6f9e1..811db036a8 100644 --- a/spec/ruby/core/array/join_spec.rb +++ b/spec/ruby/core/array/join_spec.rb @@ -24,11 +24,11 @@ describe "Array#join" do it "raises a TypeError if the separator cannot be coerced to a String by calling #to_str" do obj = mock("not a string") - -> { [1, 2].join(obj) }.should raise_error(TypeError) + -> { [1, 2].join(obj) }.should.raise(TypeError) end it "raises a TypeError if passed false as the separator" do - -> { [1, 2].join(false) }.should raise_error(TypeError) + -> { [1, 2].join(false) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/array/keep_if_spec.rb b/spec/ruby/core/array/keep_if_spec.rb index 40f7329b7c..62a65a04e8 100644 --- a/spec/ruby/core/array/keep_if_spec.rb +++ b/spec/ruby/core/array/keep_if_spec.rb @@ -4,7 +4,7 @@ require_relative 'shared/keep_if' describe "Array#keep_if" do it "returns the same array if no changes were made" do array = [1, 2, 3] - array.keep_if { true }.should equal(array) + array.keep_if { true }.should.equal?(array) end it_behaves_like :keep_if, :keep_if diff --git a/spec/ruby/core/array/last_spec.rb b/spec/ruby/core/array/last_spec.rb index d6fefada09..ed417bcd2a 100644 --- a/spec/ruby/core/array/last_spec.rb +++ b/spec/ruby/core/array/last_spec.rb @@ -28,7 +28,7 @@ describe "Array#last" do end it "raises an ArgumentError when count is negative" do - -> { [1, 2].last(-1) }.should raise_error(ArgumentError) + -> { [1, 2].last(-1) }.should.raise(ArgumentError) end it "returns the entire array when count > length" do @@ -47,10 +47,10 @@ describe "Array#last" do it "properly handles recursive arrays" do empty = ArraySpecs.empty_recursive_array - empty.last.should equal(empty) + empty.last.should.equal?(empty) array = ArraySpecs.recursive_array - array.last.should equal(array) + array.last.should.equal?(array) end it "tries to convert the passed argument to an Integer using #to_int" do @@ -60,19 +60,19 @@ describe "Array#last" do end it "raises a TypeError if the passed argument is not numeric" do - -> { [1,2].last(nil) }.should raise_error(TypeError) - -> { [1,2].last("a") }.should raise_error(TypeError) + -> { [1,2].last(nil) }.should.raise(TypeError) + -> { [1,2].last("a") }.should.raise(TypeError) obj = mock("nonnumeric") - -> { [1,2].last(obj) }.should raise_error(TypeError) + -> { [1,2].last(obj) }.should.raise(TypeError) end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[].last(0).should be_an_instance_of(Array) - ArraySpecs::MyArray[].last(2).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].last(0).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].last(1).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].last(2).should be_an_instance_of(Array) + ArraySpecs::MyArray[].last(0).should.instance_of?(Array) + ArraySpecs::MyArray[].last(2).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].last(0).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].last(1).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].last(2).should.instance_of?(Array) end it "is not destructive" do diff --git a/spec/ruby/core/array/max_spec.rb b/spec/ruby/core/array/max_spec.rb index d1c64519d0..868275a748 100644 --- a/spec/ruby/core/array/max_spec.rb +++ b/spec/ruby/core/array/max_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Array#max" do it "is defined on Array" do - [1].method(:max).owner.should equal Array + [1].method(:max).owner.should.equal? Array end it "returns nil with no values" do @@ -70,16 +70,16 @@ describe "Array#max" do it "raises a NoMethodError for elements without #<=>" do -> do [BasicObject.new, BasicObject.new].max - end.should raise_error(NoMethodError) + end.should.raise(NoMethodError) end it "raises an ArgumentError for incomparable elements" do -> do [11,"22"].max - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) -> do [11,12,22,33].max{|a, b| nil} - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end it "returns the maximum element (with block)" do diff --git a/spec/ruby/core/array/min_spec.rb b/spec/ruby/core/array/min_spec.rb index 3bdef0dd00..5913e08cf8 100644 --- a/spec/ruby/core/array/min_spec.rb +++ b/spec/ruby/core/array/min_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Array#min" do it "is defined on Array" do - [1].method(:max).owner.should equal Array + [1].method(:max).owner.should.equal? Array end it "returns nil with no values" do @@ -64,22 +64,22 @@ describe "Array#min" do end it "returns nil for an empty Enumerable" do - [].min.should be_nil + [].min.should == nil end it "raises a NoMethodError for elements without #<=>" do -> do [BasicObject.new, BasicObject.new].min - end.should raise_error(NoMethodError) + end.should.raise(NoMethodError) end it "raises an ArgumentError for incomparable elements" do -> do [11,"22"].min - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) -> do [11,12,22,33].min{|a, b| nil} - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end it "returns the minimum when using a block rule" do diff --git a/spec/ruby/core/array/multiply_spec.rb b/spec/ruby/core/array/multiply_spec.rb index eca51142fb..1ac14e1b09 100644 --- a/spec/ruby/core/array/multiply_spec.rb +++ b/spec/ruby/core/array/multiply_spec.rb @@ -17,7 +17,7 @@ describe "Array#*" do it "raises a TypeError if the argument can neither be converted to a string nor an integer" do obj = mock('not a string or integer') - ->{ [1,2] * obj }.should raise_error(TypeError) + ->{ [1,2] * obj }.should.raise(TypeError) end it "converts the passed argument to a String rather than an Integer" do @@ -28,15 +28,15 @@ describe "Array#*" do end it "raises a TypeError is the passed argument is nil" do - ->{ [1,2] * nil }.should raise_error(TypeError) + ->{ [1,2] * nil }.should.raise(TypeError) end it "raises an ArgumentError when passed 2 or more arguments" do - ->{ [1,2].send(:*, 1, 2) }.should raise_error(ArgumentError) + ->{ [1,2].send(:*, 1, 2) }.should.raise(ArgumentError) end it "raises an ArgumentError when passed no arguments" do - ->{ [1,2].send(:*) }.should raise_error(ArgumentError) + ->{ [1,2].send(:*) }.should.raise(ArgumentError) end end @@ -50,7 +50,7 @@ describe "Array#* with an integer" do it "does not return self even if the passed integer is 1" do ary = [1, 2, 3] - (ary * 1).should_not equal(ary) + (ary * 1).should_not.equal?(ary) end it "properly handles recursive arrays" do @@ -65,8 +65,8 @@ describe "Array#* with an integer" do end it "raises an ArgumentError when passed a negative integer" do - -> { [ 1, 2, 3 ] * -1 }.should raise_error(ArgumentError) - -> { [] * -1 }.should raise_error(ArgumentError) + -> { [ 1, 2, 3 ] * -1 }.should.raise(ArgumentError) + -> { [] * -1 }.should.raise(ArgumentError) end describe "with a subclass of Array" do @@ -77,14 +77,14 @@ describe "Array#* with an integer" do end it "returns an Array instance" do - (@array * 0).should be_an_instance_of(Array) - (@array * 1).should be_an_instance_of(Array) - (@array * 2).should be_an_instance_of(Array) + (@array * 0).should.instance_of?(Array) + (@array * 1).should.instance_of?(Array) + (@array * 2).should.instance_of?(Array) end it "does not call #initialize on the subclass instance" do (@array * 2).should == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end end end diff --git a/spec/ruby/core/array/new_spec.rb b/spec/ruby/core/array/new_spec.rb index b50a4857b0..b2f23e2f6b 100644 --- a/spec/ruby/core/array/new_spec.rb +++ b/spec/ruby/core/array/new_spec.rb @@ -3,31 +3,31 @@ require_relative 'fixtures/classes' describe "Array.new" do it "returns an instance of Array" do - Array.new.should be_an_instance_of(Array) + Array.new.should.instance_of?(Array) end it "returns an instance of a subclass" do - ArraySpecs::MyArray.new(1, 2).should be_an_instance_of(ArraySpecs::MyArray) + ArraySpecs::MyArray.new(1, 2).should.instance_of?(ArraySpecs::MyArray) end it "raises an ArgumentError if passed 3 or more arguments" do -> do [1, 2].send :initialize, 1, 'x', true - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) -> do [1, 2].send(:initialize, 1, 'x', true) {} - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end end describe "Array.new with no arguments" do it "returns an empty array" do - Array.new.should be_empty + Array.new.should.empty? end it "does not use the given block" do -> { - -> { Array.new { raise } }.should_not raise_error + -> { Array.new { raise } }.should_not.raise }.should complain(/warning: given block not used/, verbose: true) end end @@ -39,7 +39,7 @@ describe "Array.new with (array)" do end it "does not use the given block" do - ->{ Array.new([1, 2]) { raise } }.should_not raise_error + ->{ Array.new([1, 2]) { raise } }.should_not.raise end it "calls #to_ary to convert the value to an array" do @@ -56,7 +56,7 @@ describe "Array.new with (array)" do end it "raises a TypeError if an Array type argument and a default object" do - -> { Array.new([1, 2], 1) }.should raise_error(TypeError) + -> { Array.new([1, 2], 1) }.should.raise(TypeError) end end @@ -65,8 +65,8 @@ describe "Array.new with (size, object=nil)" do obj = [3] a = Array.new(2, obj) a.should == [obj, obj] - a[0].should equal(obj) - a[1].should equal(obj) + a[0].should.equal?(obj) + a[1].should.equal?(obj) Array.new(3, 14).should == [14, 14, 14] end @@ -76,12 +76,12 @@ describe "Array.new with (size, object=nil)" do end it "raises an ArgumentError if size is negative" do - -> { Array.new(-1, :a) }.should raise_error(ArgumentError) - -> { Array.new(-1) }.should raise_error(ArgumentError) + -> { Array.new(-1, :a) }.should.raise(ArgumentError) + -> { Array.new(-1) }.should.raise(ArgumentError) end it "raises an ArgumentError if size is too large" do - -> { Array.new(fixnum_max+1) }.should raise_error(ArgumentError) + -> { Array.new(fixnum_max+1) }.should.raise(ArgumentError) end it "calls #to_int to convert the size argument to an Integer when object is given" do @@ -99,7 +99,7 @@ describe "Array.new with (size, object=nil)" do it "raises a TypeError if the size argument is not an Integer type" do obj = mock('nonnumeric') obj.stub!(:to_ary).and_return([1, 2]) - ->{ Array.new(obj, :a) }.should raise_error(TypeError) + ->{ Array.new(obj, :a) }.should.raise(TypeError) end it "yields the index of the element and sets the element to the value of the block" do diff --git a/spec/ruby/core/array/pack/a_spec.rb b/spec/ruby/core/array/pack/a_spec.rb index f4a40502c2..03bfd8214c 100644 --- a/spec/ruby/core/array/pack/a_spec.rb +++ b/spec/ruby/core/array/pack/a_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -19,15 +19,15 @@ describe "Array#pack with format 'A'" do end it "will not implicitly convert a number to a string" do - -> { [0].pack('A') }.should raise_error(TypeError) - -> { [0].pack('a') }.should raise_error(TypeError) + -> { [0].pack('A') }.should.raise(TypeError) + -> { [0].pack('a') }.should.raise(TypeError) end it "adds all the bytes to the output when passed the '*' modifier" do ["abc"].pack("A*").should == "abc" end - it "padds the output with spaces when the count exceeds the size of the String" do + it "pads the output with spaces when the count exceeds the size of the String" do ["abc"].pack("A6").should == "abc " end @@ -55,7 +55,7 @@ describe "Array#pack with format 'a'" do ["abc"].pack("a*").should == "abc" end - it "padds the output with NULL bytes when the count exceeds the size of the String" do + it "pads the output with NULL bytes when the count exceeds the size of the String" do ["abc"].pack("a6").should == "abc\x00\x00\x00" end diff --git a/spec/ruby/core/array/pack/at_spec.rb b/spec/ruby/core/array/pack/at_spec.rb index 3942677913..bb9801440a 100644 --- a/spec/ruby/core/array/pack/at_spec.rb +++ b/spec/ruby/core/array/pack/at_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' diff --git a/spec/ruby/core/array/pack/b_spec.rb b/spec/ruby/core/array/pack/b_spec.rb index ec82b7d1ab..f7576846ef 100644 --- a/spec/ruby/core/array/pack/b_spec.rb +++ b/spec/ruby/core/array/pack/b_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -19,8 +19,8 @@ describe "Array#pack with format 'B'" do end it "will not implicitly convert a number to a string" do - -> { [0].pack('B') }.should raise_error(TypeError) - -> { [0].pack('b') }.should raise_error(TypeError) + -> { [0].pack('B') }.should.raise(TypeError) + -> { [0].pack('b') }.should.raise(TypeError) end it "encodes one bit for each character starting with the most significant bit" do diff --git a/spec/ruby/core/array/pack/buffer_spec.rb b/spec/ruby/core/array/pack/buffer_spec.rb index b77b2d1efa..d104c80186 100644 --- a/spec/ruby/core/array/pack/buffer_spec.rb +++ b/spec/ruby/core/array/pack/buffer_spec.rb @@ -7,7 +7,7 @@ describe "Array#pack with :buffer option" do n = [ 65, 66, 67 ] buffer = " "*3 result = n.pack("ccc", buffer: buffer) #=> "ABC" - result.should equal(buffer) + result.should.equal?(buffer) end it "adds result at the end of buffer content" do @@ -24,12 +24,12 @@ describe "Array#pack with :buffer option" do end it "raises TypeError exception if buffer is not String" do - -> { [65].pack("ccc", buffer: []) }.should raise_error( + -> { [65].pack("ccc", buffer: []) }.should.raise( TypeError, "buffer must be String, not Array") end it "raise FrozenError if buffer is frozen" do - -> { [65].pack("c", buffer: "frozen-string".freeze) }.should raise_error(FrozenError) + -> { [65].pack("c", buffer: "frozen-string".freeze) }.should.raise(FrozenError) end it "preserves the encoding of the given buffer" do diff --git a/spec/ruby/core/array/pack/c_spec.rb b/spec/ruby/core/array/pack/c_spec.rb index ac133ff9b6..de06207a23 100644 --- a/spec/ruby/core/array/pack/c_spec.rb +++ b/spec/ruby/core/array/pack/c_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' @@ -45,20 +45,10 @@ describe :array_pack_8bit, shared: true do [1, 2, 3, 4, 5].pack(pack_format('*')).should == "\x01\x02\x03\x04\x05" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [1, 2, 3].pack(pack_format("\000", 2)).should == "\x01\x02" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [1, 2, 3].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [1, 2, 3].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do diff --git a/spec/ruby/core/array/pack/comment_spec.rb b/spec/ruby/core/array/pack/comment_spec.rb index 254c827ccc..daf1cff06a 100644 --- a/spec/ruby/core/array/pack/comment_spec.rb +++ b/spec/ruby/core/array/pack/comment_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' diff --git a/spec/ruby/core/array/pack/h_spec.rb b/spec/ruby/core/array/pack/h_spec.rb index 2c1dac8d4a..1492d02b1f 100644 --- a/spec/ruby/core/array/pack/h_spec.rb +++ b/spec/ruby/core/array/pack/h_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -19,8 +19,8 @@ describe "Array#pack with format 'H'" do end it "will not implicitly convert a number to a string" do - -> { [0].pack('H') }.should raise_error(TypeError) - -> { [0].pack('h') }.should raise_error(TypeError) + -> { [0].pack('H') }.should.raise(TypeError) + -> { [0].pack('h') }.should.raise(TypeError) end it "encodes the first character as the most significant nibble when passed no count modifier" do diff --git a/spec/ruby/core/array/pack/m_spec.rb b/spec/ruby/core/array/pack/m_spec.rb index c6364af12d..fb670d120e 100644 --- a/spec/ruby/core/array/pack/m_spec.rb +++ b/spec/ruby/core/array/pack/m_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -155,7 +155,7 @@ describe "Array#pack with format 'M'" do it "encodes a recursive array" do empty = ArraySpecs.empty_recursive_array - empty.pack('M').should be_an_instance_of(String) + empty.pack('M').should.instance_of?(String) array = ArraySpecs.recursive_array array.pack('M').should == "1=\n" @@ -172,7 +172,7 @@ describe "Array#pack with format 'M'" do obj = mock("pack M non-string") obj.should_receive(:to_s).and_return(2) - [obj].pack("M").should be_an_instance_of(String) + [obj].pack("M").should.instance_of?(String) end it "encodes a Symbol as a String" do @@ -293,16 +293,16 @@ describe "Array#pack with format 'm'" do it "raises a TypeError if #to_str does not return a String" do obj = mock("pack m non-string") - -> { [obj].pack("m") }.should raise_error(TypeError) + -> { [obj].pack("m") }.should.raise(TypeError) end it "raises a TypeError if passed nil" do - -> { [nil].pack("m") }.should raise_error(TypeError) + -> { [nil].pack("m") }.should.raise(TypeError) end it "raises a TypeError if passed an Integer" do - -> { [0].pack("m") }.should raise_error(TypeError) - -> { [bignum_value].pack("m") }.should raise_error(TypeError) + -> { [0].pack("m") }.should.raise(TypeError) + -> { [bignum_value].pack("m") }.should.raise(TypeError) end it "does not emit a newline if passed zero as the count modifier" do diff --git a/spec/ruby/core/array/pack/percent_spec.rb b/spec/ruby/core/array/pack/percent_spec.rb index 5d56dea5fe..29b119732a 100644 --- a/spec/ruby/core/array/pack/percent_spec.rb +++ b/spec/ruby/core/array/pack/percent_spec.rb @@ -2,6 +2,6 @@ require_relative '../../../spec_helper' describe "Array#pack with format '%'" do it "raises an Argument Error" do - -> { [1].pack("%") }.should raise_error(ArgumentError) + -> { [1].pack("%") }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/array/pack/r_spec.rb b/spec/ruby/core/array/pack/r_spec.rb new file mode 100644 index 0000000000..cefe1388d2 --- /dev/null +++ b/spec/ruby/core/array/pack/r_spec.rb @@ -0,0 +1,89 @@ +# encoding: binary +require_relative '../../../spec_helper' +require_relative '../fixtures/classes' +require_relative 'shared/basic' +require_relative 'shared/numeric_basic' +require_relative 'shared/integer' + +ruby_version_is "4.1" do + describe "Array#pack with format 'R'" do + it_behaves_like :array_pack_basic, 'R' + it_behaves_like :array_pack_basic_non_float, 'R' + it_behaves_like :array_pack_arguments, 'R' + it_behaves_like :array_pack_numeric_basic, 'R' + it_behaves_like :array_pack_integer, 'R' + + it "encodes a ULEB128 integer" do + [ [[0], "\x00"], + [[1], "\x01"], + [[127], "\x7f"], + [[128], "\x80\x01"], + [[0x3fff], "\xff\x7f"], + [[0x4000], "\x80\x80\x01"], + [[0xffffffff], "\xff\xff\xff\xff\x0f"], + [[0x100000000], "\x80\x80\x80\x80\x10"], + [[0xffff_ffff_ffff_ffff], "\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01"], + [[0xffff_ffff_ffff_ffff_ffff_ffff], "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f"], + ].should be_computed_by(:pack, "R") + end + + it "encodes multiple values with '*' modifier" do + [1, 2].pack("R*").should == "\x01\x02" + [127, 128].pack("R*").should == "\x7f\x80\x01" + end + + it "raises an ArgumentError when passed a negative value" do + -> { [-1].pack("R") }.should.raise(ArgumentError) + -> { [-100].pack("R") }.should.raise(ArgumentError) + end + + it "round-trips values through pack and unpack" do + values = [0, 1, 127, 128, 0x3fff, 0x4000, 0xffffffff, 0x100000000] + values.pack("R*").unpack("R*").should == values + end + end + + describe "Array#pack with format 'r'" do + it_behaves_like :array_pack_basic, 'r' + it_behaves_like :array_pack_basic_non_float, 'r' + it_behaves_like :array_pack_arguments, 'r' + it_behaves_like :array_pack_numeric_basic, 'r' + it_behaves_like :array_pack_integer, 'r' + + it "encodes a SLEB128 integer" do + [ [[0], "\x00"], + [[1], "\x01"], + [[-1], "\x7f"], + [[-2], "\x7e"], + [[127], "\xff\x00"], + [[128], "\x80\x01"], + [[-127], "\x81\x7f"], + [[-128], "\x80\x7f"], + ].should be_computed_by(:pack, "r") + end + + it "encodes larger positive numbers" do + [0x3fff].pack("r").should == "\xff\xff\x00" + [0x4000].pack("r").should == "\x80\x80\x01" + end + + it "encodes larger negative numbers" do + [-0x3fff].pack("r").should == "\x81\x80\x7f" + [-0x4000].pack("r").should == "\x80\x80\x7f" + end + + it "encodes very large numbers" do + [0xffff_ffff_ffff_ffff_ffff_ffff].pack("r").should == "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1F" + [-0xffff_ffff_ffff_ffff_ffff_ffff].pack("r").should == "\x81\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x60" + end + + it "encodes multiple values with '*' modifier" do + [0, 1, -1].pack("r*").should == "\x00\x01\x7f" + end + + it "round-trips values through pack and unpack" do + values = [0, 1, -1, 127, -127, 128, -128, 0x3fff, -0x3fff, 0x4000, -0x4000] + values.pack("r*").unpack("r*").should == values + end + end +end diff --git a/spec/ruby/core/array/pack/shared/basic.rb b/spec/ruby/core/array/pack/shared/basic.rb index 4b28de7ed0..2894369c71 100644 --- a/spec/ruby/core/array/pack/shared/basic.rb +++ b/spec/ruby/core/array/pack/shared/basic.rb @@ -1,6 +1,6 @@ describe :array_pack_arguments, shared: true do it "raises an ArgumentError if there are fewer elements than the format requires" do - -> { [].pack(pack_format(1)) }.should raise_error(ArgumentError) + -> { [].pack(pack_format(1)) }.should.raise(ArgumentError) end end @@ -10,11 +10,11 @@ describe :array_pack_basic, shared: true do end it "raises a TypeError when passed nil" do - -> { [@obj].pack(nil) }.should raise_error(TypeError) + -> { [@obj].pack(nil) }.should.raise(TypeError) end it "raises a TypeError when passed an Integer" do - -> { [@obj].pack(1) }.should raise_error(TypeError) + -> { [@obj].pack(1) }.should.raise(TypeError) end end @@ -24,74 +24,50 @@ describe :array_pack_basic_non_float, shared: true do end it "ignores whitespace in the format string" do - [@obj, @obj].pack("a \t\n\v\f\r"+pack_format).should be_an_instance_of(String) + [@obj, @obj].pack("a \t\n\v\f\r"+pack_format).should.instance_of?(String) end it "ignores comments in the format string" do # 2 additional directives ('a') are required for the X directive - [@obj, @obj, @obj, @obj].pack("aa #{pack_format} # some comment \n#{pack_format}").should be_an_instance_of(String) + [@obj, @obj, @obj, @obj].pack("aa #{pack_format} # some comment \n#{pack_format}").should.instance_of?(String) end - ruby_version_is ""..."3.2" do - it "warns in verbose mode that a directive is unknown" do - # additional directive ('a') is required for the X directive - -> { [@obj, @obj].pack("a R" + pack_format) }.should complain(/unknown pack directive 'R'/, verbose: true) - -> { [@obj, @obj].pack("a 0" + pack_format) }.should complain(/unknown pack directive '0'/, verbose: true) - -> { [@obj, @obj].pack("a :" + pack_format) }.should complain(/unknown pack directive ':'/, verbose: true) - end - end - - ruby_version_is "3.2"..."3.3" do - # https://bugs.ruby-lang.org/issues/19150 - # NOTE: it's just a plan of the Ruby core team - it "warns that a directive is unknown" do - # additional directive ('a') is required for the X directive - -> { [@obj, @obj].pack("a R" + pack_format) }.should complain(/unknown pack directive 'R'/) - -> { [@obj, @obj].pack("a 0" + pack_format) }.should complain(/unknown pack directive '0'/) - -> { [@obj, @obj].pack("a :" + pack_format) }.should complain(/unknown pack directive ':'/) - end - end - - ruby_version_is "3.3" do - # https://bugs.ruby-lang.org/issues/19150 - # NOTE: Added this case just to not forget about the decision in the ticket - it "raise ArgumentError when a directive is unknown" do - # additional directive ('a') is required for the X directive - -> { [@obj, @obj].pack("a R" + pack_format) }.should raise_error(ArgumentError, /unknown pack directive 'R'/) - -> { [@obj, @obj].pack("a 0" + pack_format) }.should raise_error(ArgumentError, /unknown pack directive '0'/) - -> { [@obj, @obj].pack("a :" + pack_format) }.should raise_error(ArgumentError, /unknown pack directive ':'/) - end + it "raise ArgumentError when a directive is unknown" do + # additional directive ('a') is required for the X directive + -> { [@obj, @obj].pack("a K" + pack_format) }.should.raise(ArgumentError, /unknown pack directive 'K'/) + -> { [@obj, @obj].pack("a 0" + pack_format) }.should.raise(ArgumentError, /unknown pack directive '0'/) + -> { [@obj, @obj].pack("a :" + pack_format) }.should.raise(ArgumentError, /unknown pack directive ':'/) end it "calls #to_str to coerce the directives string" do d = mock("pack directive") d.should_receive(:to_str).and_return("x"+pack_format) - [@obj, @obj].pack(d).should be_an_instance_of(String) + [@obj, @obj].pack(d).should.instance_of?(String) end end describe :array_pack_basic_float, shared: true do it "ignores whitespace in the format string" do - [9.3, 4.7].pack(" \t\n\v\f\r"+pack_format).should be_an_instance_of(String) + [9.3, 4.7].pack(" \t\n\v\f\r"+pack_format).should.instance_of?(String) end it "ignores comments in the format string" do - [9.3, 4.7].pack(pack_format + "# some comment \n" + pack_format).should be_an_instance_of(String) + [9.3, 4.7].pack(pack_format + "# some comment \n" + pack_format).should.instance_of?(String) end it "calls #to_str to coerce the directives string" do d = mock("pack directive") d.should_receive(:to_str).and_return("x"+pack_format) - [1.2, 4.7].pack(d).should be_an_instance_of(String) + [1.2, 4.7].pack(d).should.instance_of?(String) end end describe :array_pack_no_platform, shared: true do it "raises ArgumentError when the format modifier is '_'" do - ->{ [1].pack(pack_format("_")) }.should raise_error(ArgumentError) + ->{ [1].pack(pack_format("_")) }.should.raise(ArgumentError) end it "raises ArgumentError when the format modifier is '!'" do - ->{ [1].pack(pack_format("!")) }.should raise_error(ArgumentError) + ->{ [1].pack(pack_format("!")) }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/array/pack/shared/encodings.rb b/spec/ruby/core/array/pack/shared/encodings.rb index 6b7ffac764..0b5a5cc8a0 100644 --- a/spec/ruby/core/array/pack/shared/encodings.rb +++ b/spec/ruby/core/array/pack/shared/encodings.rb @@ -5,12 +5,12 @@ describe :array_pack_hex, shared: true do it "raises a TypeError if the object does not respond to #to_str" do obj = mock("pack hex non-string") - -> { [obj].pack(pack_format) }.should raise_error(TypeError) + -> { [obj].pack(pack_format) }.should.raise(TypeError) end it "raises a TypeError if #to_str does not return a String" do obj = mock("pack hex non-string") obj.should_receive(:to_str).and_return(1) - -> { [obj].pack(pack_format) }.should raise_error(TypeError) + -> { [obj].pack(pack_format) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/array/pack/shared/float.rb b/spec/ruby/core/array/pack/shared/float.rb index 1780d7635e..c1efcd7677 100644 --- a/spec/ruby/core/array/pack/shared/float.rb +++ b/spec/ruby/core/array/pack/shared/float.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary describe :array_pack_float_le, shared: true do it "encodes a positive Float" do @@ -14,7 +14,7 @@ describe :array_pack_float_le, shared: true do end it "raises a TypeError if passed a String representation of a floating point number" do - -> { ["13"].pack(pack_format) }.should raise_error(TypeError) + -> { ["13"].pack(pack_format) }.should.raise(TypeError) end it "encodes the number of array elements specified by the count modifier" do @@ -25,20 +25,10 @@ describe :array_pack_float_le, shared: true do [2.9, 1.4, 8.2].pack(pack_format("*")).should == "\x9a\x999@33\xb3?33\x03A" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [5.3, 9.2].pack(pack_format("\000", 2)).should == "\x9a\x99\xa9@33\x13A" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [5.3, 9.2].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [5.3, 9.2].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -55,7 +45,7 @@ describe :array_pack_float_le, shared: true do it "encodes NaN" do nans = ["\x00\x00\xc0\xff", "\x00\x00\xc0\x7f", "\xFF\xFF\xFF\x7F"] - nans.should include([nan_value].pack(pack_format)) + nans.should.include?([nan_value].pack(pack_format)) end it "encodes a positive Float outside the range of a single precision float" do @@ -94,7 +84,7 @@ describe :array_pack_float_be, shared: true do end it "raises a TypeError if passed a String representation of a floating point number" do - -> { ["13"].pack(pack_format) }.should raise_error(TypeError) + -> { ["13"].pack(pack_format) }.should.raise(TypeError) end it "encodes the number of array elements specified by the count modifier" do @@ -105,20 +95,10 @@ describe :array_pack_float_be, shared: true do [2.9, 1.4, 8.2].pack(pack_format("*")).should == "@9\x99\x9a?\xb333A\x0333" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [5.3, 9.2].pack(pack_format("\000", 2)).should == "@\xa9\x99\x9aA\x1333" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [5.3, 9.2].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [5.3, 9.2].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -135,7 +115,7 @@ describe :array_pack_float_be, shared: true do it "encodes NaN" do nans = ["\xff\xc0\x00\x00", "\x7f\xc0\x00\x00", "\x7F\xFF\xFF\xFF"] - nans.should include([nan_value].pack(pack_format)) + nans.should.include?([nan_value].pack(pack_format)) end it "encodes a positive Float outside the range of a single precision float" do @@ -166,7 +146,7 @@ describe :array_pack_double_le, shared: true do end it "raises a TypeError if passed a String representation of a floating point number" do - -> { ["13"].pack(pack_format) }.should raise_error(TypeError) + -> { ["13"].pack(pack_format) }.should.raise(TypeError) end it "encodes the number of array elements specified by the count modifier" do @@ -177,20 +157,10 @@ describe :array_pack_double_le, shared: true do [2.9, 1.4, 8.2].pack(pack_format("*")).should == "333333\x07@ffffff\xf6?ffffff\x20@" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [5.3, 9.2].pack(pack_format("\000", 2)).should == "333333\x15@ffffff\x22@" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [5.3, 9.2].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [5.3, 9.2].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -211,7 +181,7 @@ describe :array_pack_double_le, shared: true do "\x00\x00\x00\x00\x00\x00\xf8\x7f", "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F" ] - nans.should include([nan_value].pack(pack_format)) + nans.should.include?([nan_value].pack(pack_format)) end it "encodes a positive Float outside the range of a single precision float" do @@ -237,7 +207,7 @@ describe :array_pack_double_be, shared: true do end it "raises a TypeError if passed a String representation of a floating point number" do - -> { ["13"].pack(pack_format) }.should raise_error(TypeError) + -> { ["13"].pack(pack_format) }.should.raise(TypeError) end it "encodes the number of array elements specified by the count modifier" do @@ -248,20 +218,10 @@ describe :array_pack_double_be, shared: true do [2.9, 1.4, 8.2].pack(pack_format("*")).should == "@\x07333333?\xf6ffffff@\x20ffffff" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [5.3, 9.2].pack(pack_format("\000", 2)).should == "@\x15333333@\x22ffffff" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [5.3, 9.2].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [5.3, 9.2].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -282,7 +242,7 @@ describe :array_pack_double_be, shared: true do "\x7f\xf8\x00\x00\x00\x00\x00\x00", "\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF" ] - nans.should include([nan_value].pack(pack_format)) + nans.should.include?([nan_value].pack(pack_format)) end it "encodes a positive Float outside the range of a single precision float" do diff --git a/spec/ruby/core/array/pack/shared/integer.rb b/spec/ruby/core/array/pack/shared/integer.rb index a89b5b733b..1cdd386cc1 100644 --- a/spec/ruby/core/array/pack/shared/integer.rb +++ b/spec/ruby/core/array/pack/shared/integer.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary describe :array_pack_16bit_le, shared: true do it "encodes the least significant 16 bits of a positive number" do @@ -41,21 +41,10 @@ describe :array_pack_16bit_le, shared: true do str.should == "\x78\x65\xcd\xab\x21\x43" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - str.should == "\x78\x65\xcd\xab" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -105,21 +94,10 @@ describe :array_pack_16bit_be, shared: true do str.should == "\x65\x78\xab\xcd\x43\x21" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - str.should == "\x65\x78\xab\xcd" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -169,21 +147,10 @@ describe :array_pack_32bit_le, shared: true do str.should == "\x78\x65\x43\x12\xcd\xab\xf0\xde\x21\x43\x65\x78" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - str.should == "\x78\x65\x43\x12\xcd\xab\xf0\xde" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -233,21 +200,10 @@ describe :array_pack_32bit_be, shared: true do str.should == "\x12\x43\x65\x78\xde\xf0\xab\xcd\x78\x65\x43\x21" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - str.should == "\x12\x43\x65\x78\xde\xf0\xab\xcd" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0x1243_6578, 0xdef0_abcd].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -357,21 +313,10 @@ describe :array_pack_64bit_le, shared: true do str.should == "\x56\x78\x12\x34\xcd\xab\xf0\xde\xf0\xde\xba\xdc\x21\x43\x65\x78" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) - str.should == "\x56\x78\x12\x34\xcd\xab\xf0\xde\xf0\xde\xba\xdc\x21\x43\x65\x78" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -429,21 +374,10 @@ describe :array_pack_64bit_be, shared: true do str.should == "\xde\xf0\xab\xcd\x34\x12\x78\x56\x78\x65\x43\x21\xdc\xba\xde\xf0" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - str = [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) - str.should == "\xde\xf0\xab\xcd\x34\x12\x78\x56\x78\x65\x43\x21\xdc\xba\xde\xf0" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [0xdef0_abcd_3412_7856, 0x7865_4321_dcba_def0].pack(pack_format("\000", 2)) + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do diff --git a/spec/ruby/core/array/pack/shared/numeric_basic.rb b/spec/ruby/core/array/pack/shared/numeric_basic.rb index 545e215e64..6594914933 100644 --- a/spec/ruby/core/array/pack/shared/numeric_basic.rb +++ b/spec/ruby/core/array/pack/shared/numeric_basic.rb @@ -4,15 +4,15 @@ describe :array_pack_numeric_basic, shared: true do end it "raises a TypeError when passed nil" do - -> { [nil].pack(pack_format) }.should raise_error(TypeError) + -> { [nil].pack(pack_format) }.should.raise(TypeError) end it "raises a TypeError when passed true" do - -> { [true].pack(pack_format) }.should raise_error(TypeError) + -> { [true].pack(pack_format) }.should.raise(TypeError) end it "raises a TypeError when passed false" do - -> { [false].pack(pack_format) }.should raise_error(TypeError) + -> { [false].pack(pack_format) }.should.raise(TypeError) end it "returns a binary string" do @@ -24,27 +24,27 @@ end describe :array_pack_integer, shared: true do it "raises a TypeError when the object does not respond to #to_int" do obj = mock('not an integer') - -> { [obj].pack(pack_format) }.should raise_error(TypeError) + -> { [obj].pack(pack_format) }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { ["5"].pack(pack_format) }.should raise_error(TypeError) + -> { ["5"].pack(pack_format) }.should.raise(TypeError) end end describe :array_pack_float, shared: true do it "raises a TypeError if a String does not represent a floating point number" do - -> { ["a"].pack(pack_format) }.should raise_error(TypeError) + -> { ["a"].pack(pack_format) }.should.raise(TypeError) end it "raises a TypeError when the object is not Numeric" do obj = Object.new - -> { [obj].pack(pack_format) }.should raise_error(TypeError, /can't convert Object into Float/) + -> { [obj].pack(pack_format) }.should.raise(TypeError, /can't convert Object into Float/) end it "raises a TypeError when the Numeric object does not respond to #to_f" do klass = Class.new(Numeric) obj = klass.new - -> { [obj].pack(pack_format) }.should raise_error(TypeError) + -> { [obj].pack(pack_format) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/array/pack/shared/string.rb b/spec/ruby/core/array/pack/shared/string.rb index 2f70dc3951..b02257059f 100644 --- a/spec/ruby/core/array/pack/shared/string.rb +++ b/spec/ruby/core/array/pack/shared/string.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary describe :array_pack_string, shared: true do it "adds count bytes of a String to the output" do ["abc"].pack(pack_format(2)).should == "ab" @@ -17,11 +17,11 @@ describe :array_pack_string, shared: true do end it "raises an ArgumentError when the Array is empty" do - -> { [].pack(pack_format) }.should raise_error(ArgumentError) + -> { [].pack(pack_format) }.should.raise(ArgumentError) end it "raises an ArgumentError when the Array has too few elements" do - -> { ["a"].pack(pack_format(nil, 2)) }.should raise_error(ArgumentError) + -> { ["a"].pack(pack_format(nil, 2)) }.should.raise(ArgumentError) end it "calls #to_str to convert the element to a String" do @@ -33,7 +33,7 @@ describe :array_pack_string, shared: true do it "raises a TypeError when the object does not respond to #to_str" do obj = mock("not a string") - -> { [obj].pack(pack_format) }.should raise_error(TypeError) + -> { [obj].pack(pack_format) }.should.raise(TypeError) end it "returns a string in encoding of common to the concatenated results" do diff --git a/spec/ruby/core/array/pack/shared/unicode.rb b/spec/ruby/core/array/pack/shared/unicode.rb index 4d8eaef323..58ba8a8b23 100644 --- a/spec/ruby/core/array/pack/shared/unicode.rb +++ b/spec/ruby/core/array/pack/shared/unicode.rb @@ -26,7 +26,7 @@ describe :array_pack_unicode, shared: true do it "constructs strings with valid encodings" do str = [0x85].pack("U*") str.should == "\xc2\x85" - str.valid_encoding?.should be_true + str.valid_encoding?.should == true end it "encodes values larger than UTF-8 max codepoints" do @@ -64,23 +64,13 @@ describe :array_pack_unicode, shared: true do it "raises a TypeError if #to_int does not return an Integer" do obj = mock('to_int') obj.should_receive(:to_int).and_return("5") - -> { [obj].pack("U") }.should raise_error(TypeError) + -> { [obj].pack("U") }.should.raise(TypeError) end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [1, 2, 3].pack("U\x00U").should == "\x01\x02" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [1, 2, 3].pack("U\x00U") - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [1, 2, 3].pack("U\x00U") + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -88,11 +78,11 @@ describe :array_pack_unicode, shared: true do end it "raises a RangeError if passed a negative number" do - -> { [-1].pack("U") }.should raise_error(RangeError) + -> { [-1].pack("U") }.should.raise(RangeError) end it "raises a RangeError if passed a number larger than an unsigned 32-bit integer" do - -> { [2**32].pack("U") }.should raise_error(RangeError) + -> { [2**32].pack("U") }.should.raise(RangeError) end it "sets the output string to UTF-8 encoding" do diff --git a/spec/ruby/core/array/pack/u_spec.rb b/spec/ruby/core/array/pack/u_spec.rb index b20093a647..c6a0d77eb2 100644 --- a/spec/ruby/core/array/pack/u_spec.rb +++ b/spec/ruby/core/array/pack/u_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -25,7 +25,7 @@ describe "Array#pack with format 'u'" do end it "will not implicitly convert a number to a string" do - -> { [0].pack('u') }.should raise_error(TypeError) + -> { [0].pack('u') }.should.raise(TypeError) end it "encodes an empty string as an empty string" do @@ -122,16 +122,16 @@ describe "Array#pack with format 'u'" do it "raises a TypeError if #to_str does not return a String" do obj = mock("pack m non-string") - -> { [obj].pack("u") }.should raise_error(TypeError) + -> { [obj].pack("u") }.should.raise(TypeError) end it "raises a TypeError if passed nil" do - -> { [nil].pack("u") }.should raise_error(TypeError) + -> { [nil].pack("u") }.should.raise(TypeError) end it "raises a TypeError if passed an Integer" do - -> { [0].pack("u") }.should raise_error(TypeError) - -> { [bignum_value].pack("u") }.should raise_error(TypeError) + -> { [0].pack("u") }.should.raise(TypeError) + -> { [bignum_value].pack("u") }.should.raise(TypeError) end it "sets the output string to US-ASCII encoding" do diff --git a/spec/ruby/core/array/pack/w_spec.rb b/spec/ruby/core/array/pack/w_spec.rb index 48ed4496a5..263e2a2288 100644 --- a/spec/ruby/core/array/pack/w_spec.rb +++ b/spec/ruby/core/array/pack/w_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -24,20 +24,10 @@ describe "Array#pack with format 'w'" do [obj].pack("w").should == "\x05" end - ruby_version_is ""..."3.3" do - it "ignores NULL bytes between directives" do - suppress_warning do - [1, 2, 3].pack("w\x00w").should == "\x01\x02" - end - end - end - - ruby_version_is "3.3" do - it "raise ArgumentError for NULL bytes between directives" do - -> { - [1, 2, 3].pack("w\x00w") - }.should raise_error(ArgumentError, /unknown pack directive/) - end + it "raise ArgumentError for NULL bytes between directives" do + -> { + [1, 2, 3].pack("w\x00w") + }.should.raise(ArgumentError, /unknown pack directive/) end it "ignores spaces between directives" do @@ -45,7 +35,7 @@ describe "Array#pack with format 'w'" do end it "raises an ArgumentError when passed a negative value" do - -> { [-1].pack("w") }.should raise_error(ArgumentError) + -> { [-1].pack("w") }.should.raise(ArgumentError) end it "returns a binary string" do diff --git a/spec/ruby/core/array/pack/x_spec.rb b/spec/ruby/core/array/pack/x_spec.rb index 86c3ad1aa4..7ff587a01e 100644 --- a/spec/ruby/core/array/pack/x_spec.rb +++ b/spec/ruby/core/array/pack/x_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -56,10 +56,10 @@ describe "Array#pack with format 'X'" do end it "raises an ArgumentError if the output string is empty" do - -> { [1, 2, 3].pack("XC") }.should raise_error(ArgumentError) + -> { [1, 2, 3].pack("XC") }.should.raise(ArgumentError) end it "raises an ArgumentError if the count modifier is greater than the bytes in the string" do - -> { [1, 2, 3].pack("C2X3") }.should raise_error(ArgumentError) + -> { [1, 2, 3].pack("C2X3") }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/array/pack/z_spec.rb b/spec/ruby/core/array/pack/z_spec.rb index 5ad3afd69e..5cd084c825 100644 --- a/spec/ruby/core/array/pack/z_spec.rb +++ b/spec/ruby/core/array/pack/z_spec.rb @@ -1,4 +1,4 @@ -# -*- encoding: binary -*- +# encoding: binary require_relative '../../../spec_helper' require_relative '../fixtures/classes' require_relative 'shared/basic' @@ -19,14 +19,14 @@ describe "Array#pack with format 'Z'" do end it "will not implicitly convert a number to a string" do - -> { [0].pack('Z') }.should raise_error(TypeError) + -> { [0].pack('Z') }.should.raise(TypeError) end it "adds all the bytes and appends a NULL byte when passed the '*' modifier" do ["abc"].pack("Z*").should == "abc\x00" end - it "padds the output with NULL bytes when the count exceeds the size of the String" do + it "pads the output with NULL bytes when the count exceeds the size of the String" do ["abc"].pack("Z6").should == "abc\x00\x00\x00" end diff --git a/spec/ruby/core/array/partition_spec.rb b/spec/ruby/core/array/partition_spec.rb index be36fffcab..bd3f3a6b6f 100644 --- a/spec/ruby/core/array/partition_spec.rb +++ b/spec/ruby/core/array/partition_spec.rb @@ -36,8 +36,8 @@ describe "Array#partition" do it "does not return subclass instances on Array subclasses" do result = ArraySpecs::MyArray[1, 2, 3].partition { |x| x % 2 == 0 } - result.should be_an_instance_of(Array) - result[0].should be_an_instance_of(Array) - result[1].should be_an_instance_of(Array) + result.should.instance_of?(Array) + result[0].should.instance_of?(Array) + result[1].should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/permutation_spec.rb b/spec/ruby/core/array/permutation_spec.rb index f15bd76639..b5df84b52b 100644 --- a/spec/ruby/core/array/permutation_spec.rb +++ b/spec/ruby/core/array/permutation_spec.rb @@ -11,7 +11,7 @@ describe "Array#permutation" do it "returns an Enumerator of all permutations when called without a block or arguments" do enum = @numbers.permutation - enum.should be_an_instance_of(Enumerator) + enum.should.instance_of?(Enumerator) enum.to_a.sort.should == [ [1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1] ].sort @@ -19,13 +19,13 @@ describe "Array#permutation" do it "returns an Enumerator of permutations of given length when called with an argument but no block" do enum = @numbers.permutation(1) - enum.should be_an_instance_of(Enumerator) + enum.should.instance_of?(Enumerator) enum.to_a.sort.should == [[1],[2],[3]] end it "yields all permutations to the block then returns self when called with block but no arguments" do array = @numbers.permutation {|n| @yielded << n} - array.should be_an_instance_of(Array) + array.should.instance_of?(Array) array.sort.should == @numbers.sort @yielded.sort.should == [ [1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1] @@ -34,7 +34,7 @@ describe "Array#permutation" do it "yields all permutations of given length to the block then returns self when called with block and argument" do array = @numbers.permutation(2) {|n| @yielded << n} - array.should be_an_instance_of(Array) + array.should.instance_of?(Array) array.sort.should == @numbers.sort @yielded.sort.should == [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]].sort end @@ -78,7 +78,7 @@ describe "Array#permutation" do [3, 1], [3, 2], [3, [4, 5]], [[4, 5], 1], [[4, 5], 2], [[4, 5], 3] ] - expected.each {|e| got.include?(e).should be_true} + expected.each {|e| got.include?(e).should == true} got.size.should == expected.size end diff --git a/spec/ruby/core/array/plus_spec.rb b/spec/ruby/core/array/plus_spec.rb index b7153fd3ef..7ead927fc0 100644 --- a/spec/ruby/core/array/plus_spec.rb +++ b/spec/ruby/core/array/plus_spec.rb @@ -22,14 +22,14 @@ describe "Array#+" do end it "raises a TypeError if the given argument can't be converted to an array" do - -> { [1, 2, 3] + nil }.should raise_error(TypeError) - -> { [1, 2, 3] + "abc" }.should raise_error(TypeError) + -> { [1, 2, 3] + nil }.should.raise(TypeError) + -> { [1, 2, 3] + "abc" }.should.raise(TypeError) end it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to an Array" do obj = mock("hello") obj.should_receive(:to_ary).and_raise(NoMethodError) - -> { [1, 2, 3] + obj }.should raise_error(NoMethodError) + -> { [1, 2, 3] + obj }.should.raise(NoMethodError) end end @@ -45,9 +45,9 @@ describe "Array#+" do end it "does return subclass instances with Array subclasses" do - (ArraySpecs::MyArray[1, 2, 3] + []).should be_an_instance_of(Array) - (ArraySpecs::MyArray[1, 2, 3] + ArraySpecs::MyArray[]).should be_an_instance_of(Array) - ([1, 2, 3] + ArraySpecs::MyArray[]).should be_an_instance_of(Array) + (ArraySpecs::MyArray[1, 2, 3] + []).should.instance_of?(Array) + (ArraySpecs::MyArray[1, 2, 3] + ArraySpecs::MyArray[]).should.instance_of?(Array) + ([1, 2, 3] + ArraySpecs::MyArray[]).should.instance_of?(Array) end it "does not call to_ary on array subclasses" do diff --git a/spec/ruby/core/array/pop_spec.rb b/spec/ruby/core/array/pop_spec.rb index 2a19408660..069083331c 100644 --- a/spec/ruby/core/array/pop_spec.rb +++ b/spec/ruby/core/array/pop_spec.rb @@ -31,11 +31,11 @@ describe "Array#pop" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.pop }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.pop }.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.pop }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.pop }.should.raise(FrozenError) end describe "passed a number n as an argument" do @@ -71,7 +71,7 @@ describe "Array#pop" do popped2.should == [] a.should == [] - popped1.should_not equal(popped2) + popped1.should_not.equal?(popped2) end it "returns whole elements if n exceeds size of the array" do @@ -82,14 +82,14 @@ describe "Array#pop" do it "does not return self even when it returns whole elements" do a = [1, 2, 3, 4, 5] - a.pop(5).should_not equal(a) + a.pop(5).should_not.equal?(a) a = [1, 2, 3, 4, 5] - a.pop(6).should_not equal(a) + a.pop(6).should_not.equal?(a) end it "raises an ArgumentError if n is negative" do - ->{ [1, 2, 3].pop(-1) }.should raise_error(ArgumentError) + ->{ [1, 2, 3].pop(-1) }.should.raise(ArgumentError) end it "tries to convert n to an Integer using #to_int" do @@ -104,21 +104,21 @@ describe "Array#pop" do end it "raises a TypeError when the passed n cannot be coerced to Integer" do - ->{ [1, 2].pop("cat") }.should raise_error(TypeError) - ->{ [1, 2].pop(nil) }.should raise_error(TypeError) + ->{ [1, 2].pop("cat") }.should.raise(TypeError) + ->{ [1, 2].pop(nil) }.should.raise(TypeError) end it "raises an ArgumentError if more arguments are passed" do - ->{ [1, 2].pop(1, 2) }.should raise_error(ArgumentError) + ->{ [1, 2].pop(1, 2) }.should.raise(ArgumentError) end it "does not return subclass instances with Array subclass" do - ArraySpecs::MyArray[1, 2, 3].pop(2).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].pop(2).should.instance_of?(Array) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.pop(2) }.should raise_error(FrozenError) - -> { ArraySpecs.frozen_array.pop(0) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.pop(2) }.should.raise(FrozenError) + -> { ArraySpecs.frozen_array.pop(0) }.should.raise(FrozenError) end end end diff --git a/spec/ruby/core/array/product_spec.rb b/spec/ruby/core/array/product_spec.rb index 6fb3818508..837f0eaf34 100644 --- a/spec/ruby/core/array/product_spec.rb +++ b/spec/ruby/core/array/product_spec.rb @@ -3,7 +3,7 @@ require_relative 'fixtures/classes' describe "Array#product" do it "returns converted arguments using :to_ary" do - ->{ [1].product(2..3) }.should raise_error(TypeError) + ->{ [1].product(2..3) }.should.raise(TypeError) ar = ArraySpecs::ArrayConvertible.new(2,3) [1].product(ar).should == [[1,2],[1,3]] ar.called.should == :to_ary @@ -31,7 +31,7 @@ describe "Array#product" do a = (0..100).to_a -> do a.product(a, a, a, a, a, a, a, a, a, a) - end.should raise_error(RangeError) + end.should.raise(RangeError) end describe "when given a block" do @@ -43,7 +43,7 @@ describe "Array#product" do acc = [] [1,2].product([3,4,5],[],[6,8]){|array| acc << array} - acc.should be_empty + acc.should.empty? end it "returns self" do @@ -56,18 +56,18 @@ describe "Array#product" do a = (0..100).to_a -> do a.product(a, a, a, a, a, a, a, a, a, a) - end.should raise_error(RangeError) + end.should.raise(RangeError) end end describe "when given an empty block" do it "returns self" do arr = [1,2] - arr.product([3,4,5],[6,8]){}.should equal(arr) + arr.product([3,4,5],[6,8]){}.should.equal?(arr) arr = [] - arr.product([3,4,5],[6,8]){}.should equal(arr) + arr.product([3,4,5],[6,8]){}.should.equal?(arr) arr = [1,2] - arr.product([]){}.should equal(arr) + arr.product([]){}.should.equal?(arr) end end end diff --git a/spec/ruby/core/array/rassoc_spec.rb b/spec/ruby/core/array/rassoc_spec.rb index 632a05e8b3..95e4ed1892 100644 --- a/spec/ruby/core/array/rassoc_spec.rb +++ b/spec/ruby/core/array/rassoc_spec.rb @@ -12,11 +12,11 @@ describe "Array#rassoc" do it "properly handles recursive arrays" do empty = ArraySpecs.empty_recursive_array - empty.rassoc([]).should be_nil + empty.rassoc([]).should == nil [[empty, empty]].rassoc(empty).should == [empty, empty] array = ArraySpecs.recursive_array - array.rassoc(array).should be_nil + array.rassoc(array).should == nil [[empty, array]].rassoc(array).should == [empty, array] end @@ -36,17 +36,15 @@ describe "Array#rassoc" do [[1, :foobar, o], [2, o, 1], [3, mock('foo')]].rassoc(key).should == [2, o, 1] end - ruby_version_is "3.3" do - it "calls to_ary on non-array elements" do - s1 = [1, 2] - s2 = ArraySpecs::ArrayConvertible.new(2, 3) - a = [s1, s2] + it "calls to_ary on non-array elements" do + s1 = [1, 2] + s2 = ArraySpecs::ArrayConvertible.new(2, 3) + a = [s1, s2] - s1.should_not_receive(:to_ary) - a.rassoc(2).should equal(s1) + s1.should_not_receive(:to_ary) + a.rassoc(2).should.equal?(s1) - a.rassoc(3).should == [2, 3] - s2.called.should equal(:to_ary) - end + a.rassoc(3).should == [2, 3] + s2.called.should.equal?(:to_ary) end end diff --git a/spec/ruby/core/array/reject_spec.rb b/spec/ruby/core/array/reject_spec.rb index 81a467e364..8d237b3a75 100644 --- a/spec/ruby/core/array/reject_spec.rb +++ b/spec/ruby/core/array/reject_spec.rb @@ -10,9 +10,9 @@ describe "Array#reject" do ary = [1, 2, 3, 4, 5] ary.reject { true }.should == [] ary.reject { false }.should == ary - ary.reject { false }.should_not equal ary + ary.reject { false }.should_not.equal? ary ary.reject { nil }.should == ary - ary.reject { nil }.should_not equal ary + ary.reject { nil }.should_not.equal? ary ary.reject { 5 }.should == [] ary.reject { |i| i < 3 }.should == [3, 4, 5] ary.reject { |i| i % 2 == 0 }.should == [1, 3, 5] @@ -35,7 +35,7 @@ describe "Array#reject" do end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].reject { |x| x % 2 == 0 }.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].reject { |x| x % 2 == 0 }.should.instance_of?(Array) end it "does not retain instance variables" do @@ -55,7 +55,7 @@ end describe "Array#reject!" do it "removes elements for which block is true" do a = [3, 4, 5, 6, 7, 8, 9, 10, 11] - a.reject! { |i| i % 2 == 0 }.should equal(a) + a.reject! { |i| i % 2 == 0 }.should.equal?(a) a.should == [3, 5, 7, 9, 11] a.reject! { |i| i > 8 } a.should == [3, 5, 7] @@ -105,20 +105,20 @@ describe "Array#reject!" do end it "returns an Enumerator if no block given, and the array is frozen" do - ArraySpecs.frozen_array.reject!.should be_an_instance_of(Enumerator) + ArraySpecs.frozen_array.reject!.should.instance_of?(Enumerator) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.reject! {} }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.reject! {} }.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.reject! {} }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.reject! {} }.should.raise(FrozenError) end it "raises a FrozenError on a frozen array only during iteration if called without a block" do enum = ArraySpecs.frozen_array.reject! - -> { enum.each {} }.should raise_error(FrozenError) + -> { enum.each {} }.should.raise(FrozenError) end it "does not truncate the array is the block raises an exception" do diff --git a/spec/ruby/core/array/repeated_combination_spec.rb b/spec/ruby/core/array/repeated_combination_spec.rb index b62382024a..a714f05f54 100644 --- a/spec/ruby/core/array/repeated_combination_spec.rb +++ b/spec/ruby/core/array/repeated_combination_spec.rb @@ -6,16 +6,16 @@ describe "Array#repeated_combination" do end it "returns an enumerator when no block is provided" do - @array.repeated_combination(2).should be_an_instance_of(Enumerator) + @array.repeated_combination(2).should.instance_of?(Enumerator) end it "returns self when a block is given" do - @array.repeated_combination(2){}.should equal(@array) + @array.repeated_combination(2){}.should.equal?(@array) end it "yields nothing for negative length and return self" do - @array.repeated_combination(-1){ fail }.should equal(@array) - @array.repeated_combination(-10){ fail }.should equal(@array) + @array.repeated_combination(-1){ fail }.should.equal?(@array) + @array.repeated_combination(-10){ fail }.should.equal?(@array) end it "yields the expected repeated_combinations" do diff --git a/spec/ruby/core/array/repeated_permutation_spec.rb b/spec/ruby/core/array/repeated_permutation_spec.rb index a165fda09e..c54a8c0c2b 100644 --- a/spec/ruby/core/array/repeated_permutation_spec.rb +++ b/spec/ruby/core/array/repeated_permutation_spec.rb @@ -10,13 +10,13 @@ describe "Array#repeated_permutation" do it "returns an Enumerator of all repeated permutations of given length when called without a block" do enum = @numbers.repeated_permutation(2) - enum.should be_an_instance_of(Enumerator) + enum.should.instance_of?(Enumerator) enum.to_a.sort.should == @permutations end it "yields all repeated_permutations to the block then returns self when called with block but no arguments" do yielded = [] - @numbers.repeated_permutation(2) {|n| yielded << n}.should equal(@numbers) + @numbers.repeated_permutation(2) {|n| yielded << n}.should.equal?(@numbers) yielded.sort.should == @permutations end diff --git a/spec/ruby/core/array/reverse_each_spec.rb b/spec/ruby/core/array/reverse_each_spec.rb index 59dabcd33d..8fa5ce6da1 100644 --- a/spec/ruby/core/array/reverse_each_spec.rb +++ b/spec/ruby/core/array/reverse_each_spec.rb @@ -19,7 +19,7 @@ describe "Array#reverse_each" do it "returns self" do a = [:a, :b, :c] - a.reverse_each { |x| }.should equal(a) + a.reverse_each { |x| }.should.equal?(a) end it "yields only the top level element of an empty recursive arrays" do diff --git a/spec/ruby/core/array/reverse_spec.rb b/spec/ruby/core/array/reverse_spec.rb index 05dbd2efcf..f25a484be8 100644 --- a/spec/ruby/core/array/reverse_spec.rb +++ b/spec/ruby/core/array/reverse_spec.rb @@ -16,14 +16,14 @@ describe "Array#reverse" do end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].reverse.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].reverse.should.instance_of?(Array) end end describe "Array#reverse!" do it "reverses the elements in place" do a = [6, 3, 4, 2, 1] - a.reverse!.should equal(a) + a.reverse!.should.equal?(a) a.should == [1, 2, 4, 3, 6] [].reverse!.should == [] end @@ -37,6 +37,6 @@ describe "Array#reverse!" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.reverse! }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.reverse! }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/rindex_spec.rb b/spec/ruby/core/array/rindex_spec.rb index 13de88818c..858c39dc92 100644 --- a/spec/ruby/core/array/rindex_spec.rb +++ b/spec/ruby/core/array/rindex_spec.rb @@ -41,7 +41,7 @@ describe "Array#rindex" do it "properly handles empty recursive arrays" do empty = ArraySpecs.empty_recursive_array empty.rindex(empty).should == 0 - empty.rindex(1).should be_nil + empty.rindex(1).should == nil end it "properly handles recursive arrays" do @@ -86,7 +86,7 @@ describe "Array#rindex" do describe "given no argument and no block" do it "produces an Enumerator" do enum = [4, 2, 1, 5, 1, 3].rindex - enum.should be_an_instance_of(Enumerator) + enum.should.instance_of?(Enumerator) enum.each { |x| x < 2 }.should == 4 end end diff --git a/spec/ruby/core/array/rotate_spec.rb b/spec/ruby/core/array/rotate_spec.rb index 60dcc8b113..009ce5ed49 100644 --- a/spec/ruby/core/array/rotate_spec.rb +++ b/spec/ruby/core/array/rotate_spec.rb @@ -29,10 +29,10 @@ describe "Array#rotate" do it "raises a TypeError if not passed an integer-like argument" do -> { [1, 2].rotate(nil) - }.should raise_error(TypeError) + }.should.raise(TypeError) -> { [1, 2].rotate("4") - }.should raise_error(TypeError) + }.should.raise(TypeError) end end @@ -50,18 +50,18 @@ describe "Array#rotate" do [].freeze.rotate [2].freeze.rotate(2) [1,2,3].freeze.rotate(-3) - }.should_not raise_error + }.should_not.raise end it "does not return self" do a = [1, 2, 3] - a.rotate.should_not equal(a) + a.rotate.should_not.equal?(a) a = [] - a.rotate(0).should_not equal(a) + a.rotate(0).should_not.equal?(a) end it "does not return subclass instance for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].rotate.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].rotate.should.instance_of?(Array) end end @@ -69,7 +69,7 @@ describe "Array#rotate!" do describe "when passed no argument" do it "moves the first element to the end and returns self" do a = [1, 2, 3, 4, 5] - a.rotate!.should equal(a) + a.rotate!.should.equal?(a) a.should == [2, 3, 4, 5, 1] end end @@ -77,11 +77,11 @@ describe "Array#rotate!" do describe "with an argument n" do it "moves the first (n % size) elements at the end and returns self" do a = [1, 2, 3, 4, 5] - a.rotate!(2).should equal(a) + a.rotate!(2).should.equal?(a) a.should == [3, 4, 5, 1, 2] - a.rotate!(-12).should equal(a) + a.rotate!(-12).should.equal?(a) a.should == [1, 2, 3, 4, 5] - a.rotate!(13).should equal(a) + a.rotate!(13).should.equal?(a) a.should == [4, 5, 1, 2, 3] end @@ -96,34 +96,34 @@ describe "Array#rotate!" do it "raises a TypeError if not passed an integer-like argument" do -> { [1, 2].rotate!(nil) - }.should raise_error(TypeError) + }.should.raise(TypeError) -> { [1, 2].rotate!("4") - }.should raise_error(TypeError) + }.should.raise(TypeError) end end it "does nothing and returns self when the length is zero or one" do a = [1] - a.rotate!.should equal(a) + a.rotate!.should.equal?(a) a.should == [1] - a.rotate!(2).should equal(a) + a.rotate!(2).should.equal?(a) a.should == [1] - a.rotate!(-21).should equal(a) + a.rotate!(-21).should.equal?(a) a.should == [1] a = [] - a.rotate!.should equal(a) + a.rotate!.should.equal?(a) a.should == [] - a.rotate!(2).should equal(a) + a.rotate!(2).should.equal?(a) a.should == [] - a.rotate!(-21).should equal(a) + a.rotate!(-21).should.equal?(a) a.should == [] end it "raises a FrozenError on a frozen array" do - -> { [1, 2, 3].freeze.rotate!(0) }.should raise_error(FrozenError) - -> { [1].freeze.rotate!(42) }.should raise_error(FrozenError) - -> { [].freeze.rotate! }.should raise_error(FrozenError) + -> { [1, 2, 3].freeze.rotate!(0) }.should.raise(FrozenError) + -> { [1].freeze.rotate!(42) }.should.raise(FrozenError) + -> { [].freeze.rotate! }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/sample_spec.rb b/spec/ruby/core/array/sample_spec.rb index d4e945152d..fd443b47de 100644 --- a/spec/ruby/core/array/sample_spec.rb +++ b/spec/ruby/core/array/sample_spec.rb @@ -14,23 +14,23 @@ describe "Array#sample" do end it "returns nil for an empty Array" do - [].sample.should be_nil + [].sample.should == nil end it "returns nil for an empty array when called without n and a Random is given" do - [].sample(random: Random.new(42)).should be_nil + [].sample(random: Random.new(42)).should == nil end it "returns a single value when not passed a count" do - [4].sample.should equal(4) + [4].sample.should.equal?(4) end it "returns a single value when not passed a count and a Random is given" do - [4].sample(random: Random.new(42)).should equal(4) + [4].sample(random: Random.new(42)).should.equal?(4) end it "returns a single value when not passed a count and a Random class is given" do - [4].sample(random: Random).should equal(4) + [4].sample(random: Random).should.equal?(4) end it "returns an empty Array when passed zero" do @@ -38,12 +38,12 @@ describe "Array#sample" do end it "returns an Array of elements when passed a count" do - [1, 2, 3, 4].sample(3).should be_an_instance_of(Array) + [1, 2, 3, 4].sample(3).should.instance_of?(Array) end it "returns elements from the Array" do array = [1, 2, 3, 4] - array.sample(3).all? { |x| array.should include(x) } + array.sample(3).all? { |x| array.should.include?(x) } end it "returns at most the number of elements in the Array" do @@ -67,11 +67,11 @@ describe "Array#sample" do end it "raises ArgumentError when passed a negative count" do - -> { [1, 2].sample(-1) }.should raise_error(ArgumentError) + -> { [1, 2].sample(-1) }.should.raise(ArgumentError) end it "does not return subclass instances with Array subclass" do - ArraySpecs::MyArray[1, 2, 3].sample(2).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].sample(2).should.instance_of?(Array) end describe "with options" do @@ -79,13 +79,13 @@ describe "Array#sample" do obj = mock("array_sample_random") obj.should_receive(:rand).and_return(0.5) - [1, 2].sample(random: obj).should be_an_instance_of(Integer) + [1, 2].sample(random: obj).should.instance_of?(Integer) end it "raises a NoMethodError if an object passed for the RNG does not define #rand" do obj = BasicObject.new - -> { [1, 2].sample(random: obj) }.should raise_error(NoMethodError) + -> { [1, 2].sample(random: obj) }.should.raise(NoMethodError) end describe "when the object returned by #rand is an Integer" do @@ -105,21 +105,21 @@ describe "Array#sample" do random = mock("array_sample_random") random.should_receive(:rand).and_return(-1) - -> { [1, 2].sample(random: random) }.should raise_error(RangeError) + -> { [1, 2].sample(random: random) }.should.raise(RangeError) end it "raises a RangeError if the value is equal to the Array size" do random = mock("array_sample_random") random.should_receive(:rand).and_return(2) - -> { [1, 2].sample(random: random) }.should raise_error(RangeError) + -> { [1, 2].sample(random: random) }.should.raise(RangeError) end it "raises a RangeError if the value is greater than the Array size" do random = mock("array_sample_random") random.should_receive(:rand).and_return(3) - -> { [1, 2].sample(random: random) }.should raise_error(RangeError) + -> { [1, 2].sample(random: random) }.should.raise(RangeError) end end end @@ -140,7 +140,7 @@ describe "Array#sample" do random = mock("array_sample_random") random.should_receive(:rand).and_return(value) - -> { [1, 2].sample(random: random) }.should raise_error(RangeError) + -> { [1, 2].sample(random: random) }.should.raise(RangeError) end it "raises a RangeError if the value is equal to the Array size" do @@ -149,7 +149,7 @@ describe "Array#sample" do random = mock("array_sample_random") random.should_receive(:rand).and_return(value) - -> { [1, 2].sample(random: random) }.should raise_error(RangeError) + -> { [1, 2].sample(random: random) }.should.raise(RangeError) end end end diff --git a/spec/ruby/core/array/select_spec.rb b/spec/ruby/core/array/select_spec.rb index 298b591744..e8775ee5ac 100644 --- a/spec/ruby/core/array/select_spec.rb +++ b/spec/ruby/core/array/select_spec.rb @@ -7,7 +7,7 @@ end describe "Array#select!" do it "returns nil if no changes were made in the array" do - [1, 2, 3].select! { true }.should be_nil + [1, 2, 3].select! { true }.should == nil end it_behaves_like :keep_if, :select! diff --git a/spec/ruby/core/array/shared/clone.rb b/spec/ruby/core/array/shared/clone.rb index 035b45ec99..1a45c2fe2c 100644 --- a/spec/ruby/core/array/shared/clone.rb +++ b/spec/ruby/core/array/shared/clone.rb @@ -1,14 +1,14 @@ describe :array_clone, shared: true do it "returns an Array or a subclass instance" do - [].send(@method).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2].send(@method).should be_an_instance_of(ArraySpecs::MyArray) + [].send(@method).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2].send(@method).should.instance_of?(ArraySpecs::MyArray) end it "produces a shallow copy where the references are directly copied" do a = [mock('1'), mock('2')] b = a.send @method - b.first.should equal a.first - b.last.should equal a.last + b.first.should.equal? a.first + b.last.should.equal? a.last end it "creates a new array containing all elements or the original" do diff --git a/spec/ruby/core/array/shared/collect.rb b/spec/ruby/core/array/shared/collect.rb index 030302ced6..aec51c9dc9 100644 --- a/spec/ruby/core/array/shared/collect.rb +++ b/spec/ruby/core/array/shared/collect.rb @@ -6,11 +6,11 @@ describe :array_collect, shared: true do a = ['a', 'b', 'c', 'd'] b = a.send(@method) { |i| i + '!' } b.should == ["a!", "b!", "c!", "d!"] - b.should_not equal a + b.should_not.equal? a end it "does not return subclass instance" do - ArraySpecs::MyArray[1, 2, 3].send(@method) { |x| x + 1 }.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method) { |x| x + 1 }.should.instance_of?(Array) end it "does not change self" do @@ -33,14 +33,14 @@ describe :array_collect, shared: true do it "returns an Enumerator when no block given" do a = [1, 2, 3] - a.send(@method).should be_an_instance_of(Enumerator) + a.send(@method).should.instance_of?(Enumerator) end it "raises an ArgumentError when no block and with arguments" do a = [1, 2, 3] -> { a.send(@method, :foo) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end before :all do @@ -54,14 +54,14 @@ end describe :array_collect_b, shared: true do it "replaces each element with the value returned by block" do a = [7, 9, 3, 5] - a.send(@method) { |i| i - 1 }.should equal(a) + a.send(@method) { |i| i - 1 }.should.equal?(a) a.should == [6, 8, 2, 4] end it "returns self" do a = [1, 2, 3, 4, 5] b = a.send(@method) {|i| i+1 } - a.should equal b + a.should.equal? b end it "returns the evaluated value of block but its contents is partially modified, if it broke in the block" do @@ -80,28 +80,28 @@ describe :array_collect_b, shared: true do it "returns an Enumerator when no block given, and the enumerator can modify the original array" do a = [1, 2, 3] enum = a.send(@method) - enum.should be_an_instance_of(Enumerator) + enum.should.instance_of?(Enumerator) enum.each{|i| "#{i}!" } a.should == ["1!", "2!", "3!"] end describe "when frozen" do it "raises a FrozenError" do - -> { ArraySpecs.frozen_array.send(@method) {} }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.send(@method) {} }.should.raise(FrozenError) end it "raises a FrozenError when empty" do - -> { ArraySpecs.empty_frozen_array.send(@method) {} }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.send(@method) {} }.should.raise(FrozenError) end it "raises a FrozenError when calling #each on the returned Enumerator" do enumerator = ArraySpecs.frozen_array.send(@method) - -> { enumerator.each {|x| x } }.should raise_error(FrozenError) + -> { enumerator.each {|x| x } }.should.raise(FrozenError) end it "raises a FrozenError when calling #each on the returned Enumerator when empty" do enumerator = ArraySpecs.empty_frozen_array.send(@method) - -> { enumerator.each {|x| x } }.should raise_error(FrozenError) + -> { enumerator.each {|x| x } }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/shared/difference.rb b/spec/ruby/core/array/shared/difference.rb index 3e69050d82..3fe22331bd 100644 --- a/spec/ruby/core/array/shared/difference.rb +++ b/spec/ruby/core/array/shared/difference.rb @@ -27,13 +27,13 @@ describe :array_binary_difference, shared: true do it "raises a TypeError if the argument cannot be coerced to an Array by calling #to_ary" do obj = mock('not an array') - -> { [1, 2, 3].send(@method, obj) }.should raise_error(TypeError) + -> { [1, 2, 3].send(@method, obj) }.should.raise(TypeError) end it "does not return subclass instance for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].send(@method, []).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[]).should be_an_instance_of(Array) - [1, 2, 3].send(@method, ArraySpecs::MyArray[]).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, []).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[]).should.instance_of?(Array) + [1, 2, 3].send(@method, ArraySpecs::MyArray[]).should.instance_of?(Array) end it "does not call to_ary on array subclasses" do diff --git a/spec/ruby/core/array/shared/enumeratorize.rb b/spec/ruby/core/array/shared/enumeratorize.rb index a19a5d3b9b..5beab5c4c4 100644 --- a/spec/ruby/core/array/shared/enumeratorize.rb +++ b/spec/ruby/core/array/shared/enumeratorize.rb @@ -1,5 +1,5 @@ describe :enumeratorize, shared: true do it "returns an Enumerator if no block given" do - [1,2].send(@method).should be_an_instance_of(Enumerator) + [1,2].send(@method).should.instance_of?(Enumerator) end end diff --git a/spec/ruby/core/array/shared/eql.rb b/spec/ruby/core/array/shared/eql.rb index b5d9128434..5e770bf167 100644 --- a/spec/ruby/core/array/shared/eql.rb +++ b/spec/ruby/core/array/shared/eql.rb @@ -1,59 +1,59 @@ describe :array_eql, shared: true do it "returns true if other is the same array" do a = [1] - a.send(@method, a).should be_true + a.send(@method, a).should == true end it "returns true if corresponding elements are #eql?" do - [].send(@method, []).should be_true - [1, 2, 3, 4].send(@method, [1, 2, 3, 4]).should be_true + [].send(@method, []).should == true + [1, 2, 3, 4].send(@method, [1, 2, 3, 4]).should == true end it "returns false if other is shorter than self" do - [1, 2, 3, 4].send(@method, [1, 2, 3]).should be_false + [1, 2, 3, 4].send(@method, [1, 2, 3]).should == false end it "returns false if other is longer than self" do - [1, 2, 3, 4].send(@method, [1, 2, 3, 4, 5]).should be_false + [1, 2, 3, 4].send(@method, [1, 2, 3, 4, 5]).should == false end it "returns false immediately when sizes of the arrays differ" do obj = mock('1') obj.should_not_receive(@method) - [] .send(@method, [obj] ).should be_false - [obj] .send(@method, [] ).should be_false + [] .send(@method, [obj] ).should == false + [obj] .send(@method, [] ).should == false end it "handles well recursive arrays" do a = ArraySpecs.empty_recursive_array - a .send(@method, [a] ).should be_true - a .send(@method, [[a]] ).should be_true - [a] .send(@method, a ).should be_true - [[a]] .send(@method, a ).should be_true + a .send(@method, [a] ).should == true + a .send(@method, [[a]] ).should == true + [a] .send(@method, a ).should == true + [[a]] .send(@method, a ).should == true # These may be surprising, but no difference can be # found between these arrays, so they are ==. # There is no "path" that will lead to a difference # (contrary to other examples below) a2 = ArraySpecs.empty_recursive_array - a .send(@method, a2 ).should be_true - a .send(@method, [a2] ).should be_true - a .send(@method, [[a2]] ).should be_true - [a] .send(@method, a2 ).should be_true - [[a]] .send(@method, a2 ).should be_true + a .send(@method, a2 ).should == true + a .send(@method, [a2] ).should == true + a .send(@method, [[a2]] ).should == true + [a] .send(@method, a2 ).should == true + [[a]] .send(@method, a2 ).should == true back = [] forth = [back]; back << forth; - back .send(@method, a ).should be_true + back .send(@method, a ).should == true x = []; x << x << x - x .send(@method, a ).should be_false # since x.size != a.size - x .send(@method, [a, a] ).should be_false # since x[0].size != [a, a][0].size - x .send(@method, [x, a] ).should be_false # since x[1].size != [x, a][1].size - [x, a] .send(@method, [a, x] ).should be_false # etc... - x .send(@method, [x, x] ).should be_true - x .send(@method, [[x, x], [x, x]] ).should be_true + x .send(@method, a ).should == false # since x.size != a.size + x .send(@method, [a, a] ).should == false # since x[0].size != [a, a][0].size + x .send(@method, [x, a] ).should == false # since x[1].size != [x, a][1].size + [x, a] .send(@method, [a, x] ).should == false # etc... + x .send(@method, [x, x] ).should == true + x .send(@method, [[x, x], [x, x]] ).should == true tree = []; branch = []; branch << tree << tree; tree << branch @@ -62,31 +62,31 @@ describe :array_eql, shared: true do forest = [tree, branch, :bird, a]; forest << forest forest2 = [tree2, branch2, :bird, a2]; forest2 << forest2 - forest .send(@method, forest2 ).should be_true - forest .send(@method, [tree2, branch, :bird, a, forest2]).should be_true + forest .send(@method, forest2 ).should == true + forest .send(@method, [tree2, branch, :bird, a, forest2]).should == true diffforest = [branch2, tree2, :bird, a2]; diffforest << forest2 - forest .send(@method, diffforest ).should be_false # since forest[0].size == 1 != 3 == diffforest[0] - forest .send(@method, [nil] ).should be_false - forest .send(@method, [forest] ).should be_false + forest .send(@method, diffforest ).should == false # since forest[0].size == 1 != 3 == diffforest[0] + forest .send(@method, [nil] ).should == false + forest .send(@method, [forest] ).should == false end it "does not call #to_ary on its argument" do obj = mock('to_ary') obj.should_not_receive(:to_ary) - [1, 2, 3].send(@method, obj).should be_false + [1, 2, 3].send(@method, obj).should == false end it "does not call #to_ary on Array subclasses" do ary = ArraySpecs::ToAryArray[5, 6, 7] ary.should_not_receive(:to_ary) - [5, 6, 7].send(@method, ary).should be_true + [5, 6, 7].send(@method, ary).should == true end it "ignores array class differences" do - ArraySpecs::MyArray[1, 2, 3].send(@method, [1, 2, 3]).should be_true - ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_true - [1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_true + ArraySpecs::MyArray[1, 2, 3].send(@method, [1, 2, 3]).should == true + ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should == true + [1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should == true end end diff --git a/spec/ruby/core/array/shared/index.rb b/spec/ruby/core/array/shared/index.rb index a4a0adbab6..cc6d6cfb5b 100644 --- a/spec/ruby/core/array/shared/index.rb +++ b/spec/ruby/core/array/shared/index.rb @@ -33,7 +33,7 @@ describe :array_index, shared: true do describe "given no argument and no block" do it "produces an Enumerator" do - [].send(@method).should be_an_instance_of(Enumerator) + [].send(@method).should.instance_of?(Enumerator) end end diff --git a/spec/ruby/core/array/shared/inspect.rb b/spec/ruby/core/array/shared/inspect.rb index af5128c645..7197cd7f26 100644 --- a/spec/ruby/core/array/shared/inspect.rb +++ b/spec/ruby/core/array/shared/inspect.rb @@ -2,7 +2,7 @@ require_relative '../fixtures/encoded_strings' describe :array_inspect, shared: true do it "returns a string" do - [1, 2, 3].send(@method).should be_an_instance_of(String) + [1, 2, 3].send(@method).should.instance_of?(String) end it "returns '[]' for an empty Array" do @@ -55,7 +55,7 @@ describe :array_inspect, shared: true do obj.should_receive(:inspect).and_return(obj) obj.should_receive(:to_s).and_raise(Exception) - -> { [obj].send(@method) }.should raise_error(Exception) + -> { [obj].send(@method) }.should.raise(Exception) end it "represents a recursive element with '[...]'" do diff --git a/spec/ruby/core/array/shared/intersection.rb b/spec/ruby/core/array/shared/intersection.rb index 0b4166ab63..dda72e8bd7 100644 --- a/spec/ruby/core/array/shared/intersection.rb +++ b/spec/ruby/core/array/shared/intersection.rb @@ -66,9 +66,9 @@ describe :array_intersection, shared: true do end it "does return subclass instances for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].send(@method, []).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_an_instance_of(Array) - [].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, []).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should.instance_of?(Array) + [].send(@method, ArraySpecs::MyArray[1, 2, 3]).should.instance_of?(Array) end it "does not call to_ary on array subclasses" do diff --git a/spec/ruby/core/array/shared/join.rb b/spec/ruby/core/array/shared/join.rb index 507b13e3c8..2be60a4dbc 100644 --- a/spec/ruby/core/array/shared/join.rb +++ b/spec/ruby/core/array/shared/join.rb @@ -49,13 +49,13 @@ describe :array_join_with_default_separator, shared: true do it "raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s" do obj = mock('o') class << obj; undef :to_s; end - -> { [1, obj].send(@method) }.should raise_error(NoMethodError) + -> { [1, obj].send(@method) }.should.raise(NoMethodError) end it "raises an ArgumentError when the Array is recursive" do - -> { ArraySpecs.recursive_array.send(@method) }.should raise_error(ArgumentError) - -> { ArraySpecs.head_recursive_array.send(@method) }.should raise_error(ArgumentError) - -> { ArraySpecs.empty_recursive_array.send(@method) }.should raise_error(ArgumentError) + -> { ArraySpecs.recursive_array.send(@method) }.should.raise(ArgumentError) + -> { ArraySpecs.head_recursive_array.send(@method) }.should.raise(ArgumentError) + -> { ArraySpecs.empty_recursive_array.send(@method) }.should.raise(ArgumentError) end it "uses the first encoding when other strings are compatible" do @@ -81,7 +81,7 @@ describe :array_join_with_default_separator, shared: true do it "fails for arrays with incompatibly-encoded strings" do ary_utf8_bad_binary = ArraySpecs.array_with_utf8_and_binary_strings - -> { ary_utf8_bad_binary.send(@method) }.should raise_error(EncodingError) + -> { ary_utf8_bad_binary.send(@method) }.should.raise(EncodingError) end context "when $, is not nil" do diff --git a/spec/ruby/core/array/shared/keep_if.rb b/spec/ruby/core/array/shared/keep_if.rb index 43a047c0a7..44625eebd1 100644 --- a/spec/ruby/core/array/shared/keep_if.rb +++ b/spec/ruby/core/array/shared/keep_if.rb @@ -4,12 +4,12 @@ require_relative '../shared/iterable_and_tolerating_size_increasing' describe :keep_if, shared: true do it "deletes elements for which the block returns a false value" do array = [1, 2, 3, 4, 5] - array.send(@method) {|item| item > 3 }.should equal(array) + array.send(@method) {|item| item > 3 }.should.equal?(array) array.should == [4, 5] end it "returns an enumerator if no block is given" do - [1, 2, 3].send(@method).should be_an_instance_of(Enumerator) + [1, 2, 3].send(@method).should.instance_of?(Enumerator) end it "updates the receiver after all blocks" do @@ -33,34 +33,34 @@ describe :keep_if, shared: true do end it "returns an Enumerator if no block is given" do - @frozen.send(@method).should be_an_instance_of(Enumerator) + @frozen.send(@method).should.instance_of?(Enumerator) end describe "with truthy block" do it "keeps elements after any exception" do - -> { @frozen.send(@method) { true } }.should raise_error(Exception) + -> { @frozen.send(@method) { true } }.should.raise(Exception) @frozen.should == @origin end it "raises a FrozenError" do - -> { @frozen.send(@method) { true } }.should raise_error(FrozenError) + -> { @frozen.send(@method) { true } }.should.raise(FrozenError) end end describe "with falsy block" do it "keeps elements after any exception" do - -> { @frozen.send(@method) { false } }.should raise_error(Exception) + -> { @frozen.send(@method) { false } }.should.raise(Exception) @frozen.should == @origin end it "raises a FrozenError" do - -> { @frozen.send(@method) { false } }.should raise_error(FrozenError) + -> { @frozen.send(@method) { false } }.should.raise(FrozenError) end end it "raises a FrozenError on a frozen array only during iteration if called without a block" do enum = @frozen.send(@method) - -> { enum.each {} }.should raise_error(FrozenError) + -> { enum.each {} }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/shared/push.rb b/spec/ruby/core/array/shared/push.rb index ac790fb6a4..ec406e506e 100644 --- a/spec/ruby/core/array/shared/push.rb +++ b/spec/ruby/core/array/shared/push.rb @@ -1,7 +1,7 @@ describe :array_push, shared: true do it "appends the arguments to the array" do a = [ "a", "b", "c" ] - a.send(@method, "d", "e", "f").should equal(a) + a.send(@method, "d", "e", "f").should.equal?(a) a.send(@method).should == ["a", "b", "c", "d", "e", "f"] a.send(@method, 5) a.should == ["a", "b", "c", "d", "e", "f", 5] @@ -27,7 +27,7 @@ describe :array_push, shared: true do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.send(@method, 1) }.should raise_error(FrozenError) - -> { ArraySpecs.frozen_array.send(@method) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.send(@method, 1) }.should.raise(FrozenError) + -> { ArraySpecs.frozen_array.send(@method) }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/shared/replace.rb b/spec/ruby/core/array/shared/replace.rb index 9a6e60c1b0..06bfd00795 100644 --- a/spec/ruby/core/array/shared/replace.rb +++ b/spec/ruby/core/array/shared/replace.rb @@ -2,9 +2,9 @@ describe :array_replace, shared: true do it "replaces the elements with elements from other array" do a = [1, 2, 3, 4, 5] b = ['a', 'b', 'c'] - a.send(@method, b).should equal(a) + a.send(@method, b).should.equal?(a) a.should == b - a.should_not equal(b) + a.should_not.equal?(b) a.send(@method, [4] * 10) a.should == [4] * 10 @@ -27,7 +27,7 @@ describe :array_replace, shared: true do it "returns self" do ary = [1, 2, 3] other = [:a, :b, :c] - ary.send(@method, other).should equal(ary) + ary.send(@method, other).should.equal?(ary) end it "does not make self dependent to the original array" do @@ -55,6 +55,6 @@ describe :array_replace, shared: true do it "raises a FrozenError on a frozen array" do -> { ArraySpecs.frozen_array.send(@method, ArraySpecs.frozen_array) - }.should raise_error(FrozenError) + }.should.raise(FrozenError) end end diff --git a/spec/ruby/core/array/shared/select.rb b/spec/ruby/core/array/shared/select.rb index 9c2cbf76c4..cb4f9acbb7 100644 --- a/spec/ruby/core/array/shared/select.rb +++ b/spec/ruby/core/array/shared/select.rb @@ -20,7 +20,7 @@ describe :array_select, shared: true do end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].send(@method) { true }.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method) { true }.should.instance_of?(Array) end it "properly handles recursive arrays" do diff --git a/spec/ruby/core/array/shared/slice.rb b/spec/ruby/core/array/shared/slice.rb index d2866970a5..b838d86118 100644 --- a/spec/ruby/core/array/shared/slice.rb +++ b/spec/ruby/core/array/shared/slice.rb @@ -130,12 +130,12 @@ describe :array_slice, shared: true do def from.to_int() 'cat' end def to.to_int() -2 end - -> { a.send(@method, from..to) }.should raise_error(TypeError) + -> { a.send(@method, from..to) }.should.raise(TypeError) def from.to_int() 1 end def to.to_int() 'cat' end - -> { a.send(@method, from..to) }.should raise_error(TypeError) + -> { a.send(@method, from..to) }.should.raise(TypeError) end it "returns the elements specified by Range indexes with [m..n]" do @@ -287,10 +287,10 @@ describe :array_slice, shared: true do a.send(@method, 1..0).should == [] a.send(@method, 1...0).should == [] - -> { a.send(@method, "a" .. "b") }.should raise_error(TypeError) - -> { a.send(@method, "a" ... "b") }.should raise_error(TypeError) - -> { a.send(@method, from .. "b") }.should raise_error(TypeError) - -> { a.send(@method, from ... "b") }.should raise_error(TypeError) + -> { a.send(@method, "a" .. "b") }.should.raise(TypeError) + -> { a.send(@method, "a" ... "b") }.should.raise(TypeError) + -> { a.send(@method, from .. "b") }.should.raise(TypeError) + -> { a.send(@method, from ... "b") }.should.raise(TypeError) end it "returns the same elements as [m..n] and [m...n] with Range subclasses" do @@ -398,63 +398,63 @@ describe :array_slice, shared: true do end it "returns a Array instance with [n, m]" do - @array.send(@method, 0, 2).should be_an_instance_of(Array) + @array.send(@method, 0, 2).should.instance_of?(Array) end it "returns a Array instance with [-n, m]" do - @array.send(@method, -3, 2).should be_an_instance_of(Array) + @array.send(@method, -3, 2).should.instance_of?(Array) end it "returns a Array instance with [n..m]" do - @array.send(@method, 1..3).should be_an_instance_of(Array) + @array.send(@method, 1..3).should.instance_of?(Array) end it "returns a Array instance with [n...m]" do - @array.send(@method, 1...3).should be_an_instance_of(Array) + @array.send(@method, 1...3).should.instance_of?(Array) end it "returns a Array instance with [-n..-m]" do - @array.send(@method, -3..-1).should be_an_instance_of(Array) + @array.send(@method, -3..-1).should.instance_of?(Array) end it "returns a Array instance with [-n...-m]" do - @array.send(@method, -3...-1).should be_an_instance_of(Array) + @array.send(@method, -3...-1).should.instance_of?(Array) end it "returns an empty array when m == n with [m...n]" do @array.send(@method, 1...1).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "returns an empty array with [0...0]" do @array.send(@method, 0...0).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "returns an empty array when m > n and m, n are positive with [m..n]" do @array.send(@method, 3..2).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "returns an empty array when m > n and m, n are negative with [m..n]" do @array.send(@method, -2..-3).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "returns [] if index == array.size with [index, length]" do @array.send(@method, 5, 2).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "returns [] if the index is valid but length is zero with [index, length]" do @array.send(@method, 0, 0).should == [] @array.send(@method, 2, 0).should == [] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end it "does not call #initialize on the subclass instance" do @array.send(@method, 0, 3).should == [1, 2, 3] - ScratchPad.recorded.should be_nil + ScratchPad.recorded.should == nil end end @@ -462,13 +462,13 @@ describe :array_slice, shared: true do array = [1, 2, 3, 4, 5, 6] obj = mock('large value') obj.should_receive(:to_int).and_return(bignum_value) - -> { array.send(@method, obj) }.should raise_error(RangeError) + -> { array.send(@method, obj) }.should.raise(RangeError) obj = 8e19 - -> { array.send(@method, obj) }.should raise_error(RangeError) + -> { array.send(@method, obj) }.should.raise(RangeError) # boundary value when longs are 64 bits - -> { array.send(@method, 2.0**63) }.should raise_error(RangeError) + -> { array.send(@method, 2.0**63) }.should.raise(RangeError) # just under the boundary value when longs are 64 bits array.send(@method, max_long.to_f.prev_float).should == nil @@ -478,20 +478,20 @@ describe :array_slice, shared: true do array = [1, 2, 3, 4, 5, 6] obj = mock('large value') obj.should_receive(:to_int).and_return(bignum_value) - -> { array.send(@method, 1, obj) }.should raise_error(RangeError) + -> { array.send(@method, 1, obj) }.should.raise(RangeError) obj = 8e19 - -> { array.send(@method, 1, obj) }.should raise_error(RangeError) + -> { array.send(@method, 1, obj) }.should.raise(RangeError) end it "raises a type error if a range is passed with a length" do - ->{ [1, 2, 3].send(@method, 1..2, 1) }.should raise_error(TypeError) + ->{ [1, 2, 3].send(@method, 1..2, 1) }.should.raise(TypeError) end it "raises a RangeError if passed a range with a bound that is too large" do array = [1, 2, 3, 4, 5, 6] - -> { array.send(@method, bignum_value..(bignum_value + 1)) }.should raise_error(RangeError) - -> { array.send(@method, 0..bignum_value) }.should raise_error(RangeError) + -> { array.send(@method, bignum_value..(bignum_value + 1)) }.should.raise(RangeError) + -> { array.send(@method, 0..bignum_value) }.should.raise(RangeError) end it "can accept endless ranges" do @@ -718,17 +718,17 @@ describe :array_slice, shared: true do it "has range with bounds outside of array" do # end is equal to array's length @array.send(@method, (0..6).step(1)).should == [0, 1, 2, 3, 4, 5] - -> { @array.send(@method, (0..6).step(2)) }.should raise_error(RangeError) + -> { @array.send(@method, (0..6).step(2)) }.should.raise(RangeError) # end is greater than length with positive steps @array.send(@method, (1..6).step(2)).should == [1, 3, 5] @array.send(@method, (2..7).step(2)).should == [2, 4] - -> { @array.send(@method, (2..8).step(2)) }.should raise_error(RangeError) + -> { @array.send(@method, (2..8).step(2)) }.should.raise(RangeError) # begin is greater than length with negative steps @array.send(@method, (6..1).step(-2)).should == [5, 3, 1] @array.send(@method, (7..2).step(-2)).should == [5, 3] - -> { @array.send(@method, (8..2).step(-2)) }.should raise_error(RangeError) + -> { @array.send(@method, (8..2).step(-2)) }.should.raise(RangeError) end it "has endless range with start outside of array's bounds" do @@ -736,7 +736,7 @@ describe :array_slice, shared: true do @array.send(@method, eval("(7..).step(1)")).should == nil @array.send(@method, eval("(6..).step(2)")).should == [] - -> { @array.send(@method, eval("(7..).step(2)")) }.should raise_error(RangeError) + -> { @array.send(@method, eval("(7..).step(2)")) }.should.raise(RangeError) end end @@ -754,99 +754,97 @@ describe :array_slice, shared: true do a.send(@method, (...-9)).should == [] end - ruby_version_is "3.2" do - describe "can be sliced with Enumerator::ArithmeticSequence" do - it "with infinite/inverted ranges and negative steps" do - @array = [0, 1, 2, 3, 4, 5] - @array.send(@method, (2..).step(-1)).should == [2, 1, 0] - @array.send(@method, (2..).step(-2)).should == [2, 0] - @array.send(@method, (2..).step(-3)).should == [2] - @array.send(@method, (2..).step(-4)).should == [2] - - @array.send(@method, (-3..).step(-1)).should == [3, 2, 1, 0] - @array.send(@method, (-3..).step(-2)).should == [3, 1] - @array.send(@method, (-3..).step(-3)).should == [3, 0] - @array.send(@method, (-3..).step(-4)).should == [3] - @array.send(@method, (-3..).step(-5)).should == [3] - - @array.send(@method, (..0).step(-1)).should == [5, 4, 3, 2, 1, 0] - @array.send(@method, (..0).step(-2)).should == [5, 3, 1] - @array.send(@method, (..0).step(-3)).should == [5, 2] - @array.send(@method, (..0).step(-4)).should == [5, 1] - @array.send(@method, (..0).step(-5)).should == [5, 0] - @array.send(@method, (..0).step(-6)).should == [5] - @array.send(@method, (..0).step(-7)).should == [5] - - @array.send(@method, (...0).step(-1)).should == [5, 4, 3, 2, 1] - @array.send(@method, (...0).step(-2)).should == [5, 3, 1] - @array.send(@method, (...0).step(-3)).should == [5, 2] - @array.send(@method, (...0).step(-4)).should == [5, 1] - @array.send(@method, (...0).step(-5)).should == [5] - @array.send(@method, (...0).step(-6)).should == [5] - - @array.send(@method, (...1).step(-1)).should == [5, 4, 3, 2] - @array.send(@method, (...1).step(-2)).should == [5, 3] - @array.send(@method, (...1).step(-3)).should == [5, 2] - @array.send(@method, (...1).step(-4)).should == [5] - @array.send(@method, (...1).step(-5)).should == [5] - - @array.send(@method, (..-5).step(-1)).should == [5, 4, 3, 2, 1] - @array.send(@method, (..-5).step(-2)).should == [5, 3, 1] - @array.send(@method, (..-5).step(-3)).should == [5, 2] - @array.send(@method, (..-5).step(-4)).should == [5, 1] - @array.send(@method, (..-5).step(-5)).should == [5] - @array.send(@method, (..-5).step(-6)).should == [5] - - @array.send(@method, (...-5).step(-1)).should == [5, 4, 3, 2] - @array.send(@method, (...-5).step(-2)).should == [5, 3] - @array.send(@method, (...-5).step(-3)).should == [5, 2] - @array.send(@method, (...-5).step(-4)).should == [5] - @array.send(@method, (...-5).step(-5)).should == [5] - - @array.send(@method, (4..1).step(-1)).should == [4, 3, 2, 1] - @array.send(@method, (4..1).step(-2)).should == [4, 2] - @array.send(@method, (4..1).step(-3)).should == [4, 1] - @array.send(@method, (4..1).step(-4)).should == [4] - @array.send(@method, (4..1).step(-5)).should == [4] - - @array.send(@method, (4...1).step(-1)).should == [4, 3, 2] - @array.send(@method, (4...1).step(-2)).should == [4, 2] - @array.send(@method, (4...1).step(-3)).should == [4] - @array.send(@method, (4...1).step(-4)).should == [4] - - @array.send(@method, (-2..1).step(-1)).should == [4, 3, 2, 1] - @array.send(@method, (-2..1).step(-2)).should == [4, 2] - @array.send(@method, (-2..1).step(-3)).should == [4, 1] - @array.send(@method, (-2..1).step(-4)).should == [4] - @array.send(@method, (-2..1).step(-5)).should == [4] - - @array.send(@method, (-2...1).step(-1)).should == [4, 3, 2] - @array.send(@method, (-2...1).step(-2)).should == [4, 2] - @array.send(@method, (-2...1).step(-3)).should == [4] - @array.send(@method, (-2...1).step(-4)).should == [4] - - @array.send(@method, (4..-5).step(-1)).should == [4, 3, 2, 1] - @array.send(@method, (4..-5).step(-2)).should == [4, 2] - @array.send(@method, (4..-5).step(-3)).should == [4, 1] - @array.send(@method, (4..-5).step(-4)).should == [4] - @array.send(@method, (4..-5).step(-5)).should == [4] - - @array.send(@method, (4...-5).step(-1)).should == [4, 3, 2] - @array.send(@method, (4...-5).step(-2)).should == [4, 2] - @array.send(@method, (4...-5).step(-3)).should == [4] - @array.send(@method, (4...-5).step(-4)).should == [4] - - @array.send(@method, (-2..-5).step(-1)).should == [4, 3, 2, 1] - @array.send(@method, (-2..-5).step(-2)).should == [4, 2] - @array.send(@method, (-2..-5).step(-3)).should == [4, 1] - @array.send(@method, (-2..-5).step(-4)).should == [4] - @array.send(@method, (-2..-5).step(-5)).should == [4] - - @array.send(@method, (-2...-5).step(-1)).should == [4, 3, 2] - @array.send(@method, (-2...-5).step(-2)).should == [4, 2] - @array.send(@method, (-2...-5).step(-3)).should == [4] - @array.send(@method, (-2...-5).step(-4)).should == [4] - end + describe "can be sliced with Enumerator::ArithmeticSequence" do + it "with infinite/inverted ranges and negative steps" do + @array = [0, 1, 2, 3, 4, 5] + @array.send(@method, (2..).step(-1)).should == [2, 1, 0] + @array.send(@method, (2..).step(-2)).should == [2, 0] + @array.send(@method, (2..).step(-3)).should == [2] + @array.send(@method, (2..).step(-4)).should == [2] + + @array.send(@method, (-3..).step(-1)).should == [3, 2, 1, 0] + @array.send(@method, (-3..).step(-2)).should == [3, 1] + @array.send(@method, (-3..).step(-3)).should == [3, 0] + @array.send(@method, (-3..).step(-4)).should == [3] + @array.send(@method, (-3..).step(-5)).should == [3] + + @array.send(@method, (..0).step(-1)).should == [5, 4, 3, 2, 1, 0] + @array.send(@method, (..0).step(-2)).should == [5, 3, 1] + @array.send(@method, (..0).step(-3)).should == [5, 2] + @array.send(@method, (..0).step(-4)).should == [5, 1] + @array.send(@method, (..0).step(-5)).should == [5, 0] + @array.send(@method, (..0).step(-6)).should == [5] + @array.send(@method, (..0).step(-7)).should == [5] + + @array.send(@method, (...0).step(-1)).should == [5, 4, 3, 2, 1] + @array.send(@method, (...0).step(-2)).should == [5, 3, 1] + @array.send(@method, (...0).step(-3)).should == [5, 2] + @array.send(@method, (...0).step(-4)).should == [5, 1] + @array.send(@method, (...0).step(-5)).should == [5] + @array.send(@method, (...0).step(-6)).should == [5] + + @array.send(@method, (...1).step(-1)).should == [5, 4, 3, 2] + @array.send(@method, (...1).step(-2)).should == [5, 3] + @array.send(@method, (...1).step(-3)).should == [5, 2] + @array.send(@method, (...1).step(-4)).should == [5] + @array.send(@method, (...1).step(-5)).should == [5] + + @array.send(@method, (..-5).step(-1)).should == [5, 4, 3, 2, 1] + @array.send(@method, (..-5).step(-2)).should == [5, 3, 1] + @array.send(@method, (..-5).step(-3)).should == [5, 2] + @array.send(@method, (..-5).step(-4)).should == [5, 1] + @array.send(@method, (..-5).step(-5)).should == [5] + @array.send(@method, (..-5).step(-6)).should == [5] + + @array.send(@method, (...-5).step(-1)).should == [5, 4, 3, 2] + @array.send(@method, (...-5).step(-2)).should == [5, 3] + @array.send(@method, (...-5).step(-3)).should == [5, 2] + @array.send(@method, (...-5).step(-4)).should == [5] + @array.send(@method, (...-5).step(-5)).should == [5] + + @array.send(@method, (4..1).step(-1)).should == [4, 3, 2, 1] + @array.send(@method, (4..1).step(-2)).should == [4, 2] + @array.send(@method, (4..1).step(-3)).should == [4, 1] + @array.send(@method, (4..1).step(-4)).should == [4] + @array.send(@method, (4..1).step(-5)).should == [4] + + @array.send(@method, (4...1).step(-1)).should == [4, 3, 2] + @array.send(@method, (4...1).step(-2)).should == [4, 2] + @array.send(@method, (4...1).step(-3)).should == [4] + @array.send(@method, (4...1).step(-4)).should == [4] + + @array.send(@method, (-2..1).step(-1)).should == [4, 3, 2, 1] + @array.send(@method, (-2..1).step(-2)).should == [4, 2] + @array.send(@method, (-2..1).step(-3)).should == [4, 1] + @array.send(@method, (-2..1).step(-4)).should == [4] + @array.send(@method, (-2..1).step(-5)).should == [4] + + @array.send(@method, (-2...1).step(-1)).should == [4, 3, 2] + @array.send(@method, (-2...1).step(-2)).should == [4, 2] + @array.send(@method, (-2...1).step(-3)).should == [4] + @array.send(@method, (-2...1).step(-4)).should == [4] + + @array.send(@method, (4..-5).step(-1)).should == [4, 3, 2, 1] + @array.send(@method, (4..-5).step(-2)).should == [4, 2] + @array.send(@method, (4..-5).step(-3)).should == [4, 1] + @array.send(@method, (4..-5).step(-4)).should == [4] + @array.send(@method, (4..-5).step(-5)).should == [4] + + @array.send(@method, (4...-5).step(-1)).should == [4, 3, 2] + @array.send(@method, (4...-5).step(-2)).should == [4, 2] + @array.send(@method, (4...-5).step(-3)).should == [4] + @array.send(@method, (4...-5).step(-4)).should == [4] + + @array.send(@method, (-2..-5).step(-1)).should == [4, 3, 2, 1] + @array.send(@method, (-2..-5).step(-2)).should == [4, 2] + @array.send(@method, (-2..-5).step(-3)).should == [4, 1] + @array.send(@method, (-2..-5).step(-4)).should == [4] + @array.send(@method, (-2..-5).step(-5)).should == [4] + + @array.send(@method, (-2...-5).step(-1)).should == [4, 3, 2] + @array.send(@method, (-2...-5).step(-2)).should == [4, 2] + @array.send(@method, (-2...-5).step(-3)).should == [4] + @array.send(@method, (-2...-5).step(-4)).should == [4] end end diff --git a/spec/ruby/core/array/shared/union.rb b/spec/ruby/core/array/shared/union.rb index 0b60df9ca4..0b225b9a31 100644 --- a/spec/ruby/core/array/shared/union.rb +++ b/spec/ruby/core/array/shared/union.rb @@ -60,9 +60,9 @@ describe :array_binary_union, shared: true do end it "does not return subclass instances for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].send(@method, []).should be_an_instance_of(Array) - ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_an_instance_of(Array) - [].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, []).should.instance_of?(Array) + ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should.instance_of?(Array) + [].send(@method, ArraySpecs::MyArray[1, 2, 3]).should.instance_of?(Array) end it "does not call to_ary on array subclasses" do diff --git a/spec/ruby/core/array/shared/unshift.rb b/spec/ruby/core/array/shared/unshift.rb index 4941e098f6..b636347cd3 100644 --- a/spec/ruby/core/array/shared/unshift.rb +++ b/spec/ruby/core/array/shared/unshift.rb @@ -1,9 +1,9 @@ describe :array_unshift, shared: true do it "prepends object to the original array" do a = [1, 2, 3] - a.send(@method, "a").should equal(a) + a.send(@method, "a").should.equal?(a) a.should == ['a', 1, 2, 3] - a.send(@method).should equal(a) + a.send(@method).should.equal?(a) a.should == ['a', 1, 2, 3] a.send(@method, 5, 4, 3) a.should == [5, 4, 3, 'a', 1, 2, 3] @@ -41,15 +41,15 @@ describe :array_unshift, shared: true do end it "raises a FrozenError on a frozen array when the array is modified" do - -> { ArraySpecs.frozen_array.send(@method, 1) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.send(@method, 1) }.should.raise(FrozenError) end # see [ruby-core:23666] it "raises a FrozenError on a frozen array when the array would not be modified" do - -> { ArraySpecs.frozen_array.send(@method) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.send(@method) }.should.raise(FrozenError) end - # https://github.com/oracle/truffleruby/issues/2772 + # https://github.com/truffleruby/truffleruby/issues/2772 it "doesn't rely on Array#[]= so it can be overridden" do subclass = Class.new(Array) do def []=(*) diff --git a/spec/ruby/core/array/shift_spec.rb b/spec/ruby/core/array/shift_spec.rb index 6b4ef39f77..09dfa79c45 100644 --- a/spec/ruby/core/array/shift_spec.rb +++ b/spec/ruby/core/array/shift_spec.rb @@ -31,10 +31,10 @@ describe "Array#shift" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.shift }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.shift }.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.shift }.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.shift }.should.raise(FrozenError) end describe "passed a number n as an argument" do @@ -72,7 +72,7 @@ describe "Array#shift" do popped2.should == [] a.should == [] - popped1.should_not equal(popped2) + popped1.should_not.equal?(popped2) end it "returns whole elements if n exceeds size of the array" do @@ -83,14 +83,14 @@ describe "Array#shift" do it "does not return self even when it returns whole elements" do a = [1, 2, 3, 4, 5] - a.shift(5).should_not equal(a) + a.shift(5).should_not.equal?(a) a = [1, 2, 3, 4, 5] - a.shift(6).should_not equal(a) + a.shift(6).should_not.equal?(a) end it "raises an ArgumentError if n is negative" do - ->{ [1, 2, 3].shift(-1) }.should raise_error(ArgumentError) + ->{ [1, 2, 3].shift(-1) }.should.raise(ArgumentError) end it "tries to convert n to an Integer using #to_int" do @@ -105,16 +105,16 @@ describe "Array#shift" do end it "raises a TypeError when the passed n cannot be coerced to Integer" do - ->{ [1, 2].shift("cat") }.should raise_error(TypeError) - ->{ [1, 2].shift(nil) }.should raise_error(TypeError) + ->{ [1, 2].shift("cat") }.should.raise(TypeError) + ->{ [1, 2].shift(nil) }.should.raise(TypeError) end it "raises an ArgumentError if more arguments are passed" do - ->{ [1, 2].shift(1, 2) }.should raise_error(ArgumentError) + ->{ [1, 2].shift(1, 2) }.should.raise(ArgumentError) end it "does not return subclass instances with Array subclass" do - ArraySpecs::MyArray[1, 2, 3].shift(2).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].shift(2).should.instance_of?(Array) end end end diff --git a/spec/ruby/core/array/shuffle_spec.rb b/spec/ruby/core/array/shuffle_spec.rb index b84394bcb5..9bc9df73ac 100644 --- a/spec/ruby/core/array/shuffle_spec.rb +++ b/spec/ruby/core/array/shuffle_spec.rb @@ -10,7 +10,7 @@ describe "Array#shuffle" do s.sort.should == a different ||= (a != s) end - different.should be_true # Will fail once in a blue moon (4!^10) + different.should == true # Will fail once in a blue moon (4!^10) end it "is not destructive" do @@ -22,7 +22,7 @@ describe "Array#shuffle" do end it "does not return subclass instances with Array subclass" do - ArraySpecs::MyArray[1, 2, 3].shuffle.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].shuffle.should.instance_of?(Array) end it "calls #rand on the Object passed by the :random key in the arguments Hash" do @@ -31,24 +31,24 @@ describe "Array#shuffle" do result = [1, 2].shuffle(random: obj) result.size.should == 2 - result.should include(1, 2) + result.sort.should == [1, 2] end it "raises a NoMethodError if an object passed for the RNG does not define #rand" do obj = BasicObject.new - -> { [1, 2].shuffle(random: obj) }.should raise_error(NoMethodError) + -> { [1, 2].shuffle(random: obj) }.should.raise(NoMethodError) end it "accepts a Float for the value returned by #rand" do random = mock("array_shuffle_random") random.should_receive(:rand).at_least(1).times.and_return(0.3) - [1, 2].shuffle(random: random).should be_an_instance_of(Array) + [1, 2].shuffle(random: random).should.instance_of?(Array) end it "accepts a Random class for the value for random: argument" do - [1, 2].shuffle(random: Random).should be_an_instance_of(Array) + [1, 2].shuffle(random: Random).should.instance_of?(Array) end it "calls #to_int on the Object returned by #rand" do @@ -57,7 +57,7 @@ describe "Array#shuffle" do random = mock("array_shuffle_random") random.should_receive(:rand).at_least(1).times.and_return(value) - [1, 2].shuffle(random: random).should be_an_instance_of(Array) + [1, 2].shuffle(random: random).should.instance_of?(Array) end it "raises a RangeError if the value is less than zero" do @@ -66,7 +66,7 @@ describe "Array#shuffle" do random = mock("array_shuffle_random") random.should_receive(:rand).and_return(value) - -> { [1, 2].shuffle(random: random) }.should raise_error(RangeError) + -> { [1, 2].shuffle(random: random) }.should.raise(RangeError) end it "raises a RangeError if the value is equal to the Array size" do @@ -75,7 +75,7 @@ describe "Array#shuffle" do random = mock("array_shuffle_random") random.should_receive(:rand).at_least(1).times.and_return(value) - -> { [1, 2].shuffle(random: random) }.should raise_error(RangeError) + -> { [1, 2].shuffle(random: random) }.should.raise(RangeError) end it "raises a RangeError if the value is greater than the Array size" do @@ -84,7 +84,7 @@ describe "Array#shuffle" do random = mock("array_shuffle_random") random.should_receive(:rand).at_least(1).times.and_return(value) - -> { [1, 2].shuffle(random: random) }.should raise_error(RangeError) + -> { [1, 2].shuffle(random: random) }.should.raise(RangeError) end end @@ -98,13 +98,13 @@ describe "Array#shuffle!" do a.sort.should == [1, 2, 3, 4] different ||= (a != [1, 2, 3, 4]) end - different.should be_true # Will fail once in a blue moon (4!^10) - a.should equal(original) + different.should == true # Will fail once in a blue moon (4!^10) + a.should.equal?(original) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.shuffle! }.should raise_error(FrozenError) - -> { ArraySpecs.empty_frozen_array.shuffle! }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.shuffle! }.should.raise(FrozenError) + -> { ArraySpecs.empty_frozen_array.shuffle! }.should.raise(FrozenError) end it "matches CRuby with random:" do diff --git a/spec/ruby/core/array/slice_spec.rb b/spec/ruby/core/array/slice_spec.rb index 731c129251..eb7e47d947 100644 --- a/spec/ruby/core/array/slice_spec.rb +++ b/spec/ruby/core/array/slice_spec.rb @@ -116,8 +116,8 @@ describe "Array#slice!" do a.slice!(from .. to).should == [2, 3, 4] a.should == [1, 5] - -> { a.slice!("a" .. "b") }.should raise_error(TypeError) - -> { a.slice!(from .. "b") }.should raise_error(TypeError) + -> { a.slice!("a" .. "b") }.should.raise(TypeError) + -> { a.slice!(from .. "b") }.should.raise(TypeError) end it "returns last element for consecutive calls at zero index" do @@ -151,7 +151,7 @@ describe "Array#slice!" do end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.slice!(0, 0) }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.slice!(0, 0) }.should.raise(FrozenError) end it "works with endless ranges" do @@ -188,27 +188,27 @@ describe "Array#slice!" do end it "returns a Array instance with [n, m]" do - @array.slice!(0, 2).should be_an_instance_of(Array) + @array.slice!(0, 2).should.instance_of?(Array) end it "returns a Array instance with [-n, m]" do - @array.slice!(-3, 2).should be_an_instance_of(Array) + @array.slice!(-3, 2).should.instance_of?(Array) end it "returns a Array instance with [n..m]" do - @array.slice!(1..3).should be_an_instance_of(Array) + @array.slice!(1..3).should.instance_of?(Array) end it "returns a Array instance with [n...m]" do - @array.slice!(1...3).should be_an_instance_of(Array) + @array.slice!(1...3).should.instance_of?(Array) end it "returns a Array instance with [-n..-m]" do - @array.slice!(-3..-1).should be_an_instance_of(Array) + @array.slice!(-3..-1).should.instance_of?(Array) end it "returns a Array instance with [-n...-m]" do - @array.slice!(-3...-1).should be_an_instance_of(Array) + @array.slice!(-3...-1).should.instance_of?(Array) end end end diff --git a/spec/ruby/core/array/sort_by_spec.rb b/spec/ruby/core/array/sort_by_spec.rb index 0334f953f6..132abb028a 100644 --- a/spec/ruby/core/array/sort_by_spec.rb +++ b/spec/ruby/core/array/sort_by_spec.rb @@ -11,30 +11,30 @@ describe "Array#sort_by!" do end it "returns an Enumerator if not given a block" do - (1..10).to_a.sort_by!.should be_an_instance_of(Enumerator) + (1..10).to_a.sort_by!.should.instance_of?(Enumerator) end it "completes when supplied a block that always returns the same result" do a = [2, 3, 5, 1, 4] a.sort_by!{ 1 } - a.should be_an_instance_of(Array) + a.should.instance_of?(Array) a.sort_by!{ 0 } - a.should be_an_instance_of(Array) + a.should.instance_of?(Array) a.sort_by!{ -1 } - a.should be_an_instance_of(Array) + a.should.instance_of?(Array) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.sort_by! {}}.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.sort_by! {}}.should.raise(FrozenError) end it "raises a FrozenError on an empty frozen array" do - -> { ArraySpecs.empty_frozen_array.sort_by! {}}.should raise_error(FrozenError) + -> { ArraySpecs.empty_frozen_array.sort_by! {}}.should.raise(FrozenError) end it "raises a FrozenError on a frozen array only during iteration if called without a block" do enum = ArraySpecs.frozen_array.sort_by! - -> { enum.each {} }.should raise_error(FrozenError) + -> { enum.each {} }.should.raise(FrozenError) end it "returns the specified value when it would break in the given block" do @@ -47,7 +47,7 @@ describe "Array#sort_by!" do ary.sort_by!{|x,y| break if x==i; x<=>y} ary } - partially_sorted.any?{|ary| ary != [1, 2, 3, 4, 5]}.should be_true + partially_sorted.any?{|ary| ary != [1, 2, 3, 4, 5]}.should == true end it "changes nothing when called on a single element array" do diff --git a/spec/ruby/core/array/sort_spec.rb b/spec/ruby/core/array/sort_spec.rb index e20b650516..27300c3385 100644 --- a/spec/ruby/core/array/sort_spec.rb +++ b/spec/ruby/core/array/sort_spec.rb @@ -42,7 +42,7 @@ describe "Array#sort" do a = [1, 2, 3] sorted = a.sort sorted.should == a - sorted.should_not equal(a) + sorted.should_not.equal?(a) end it "properly handles recursive arrays" do @@ -68,7 +68,7 @@ describe "Array#sort" do -> { [o, 1].sort - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "may take a block which is used to determine the order of objects a and b described as -1, 0 or +1" do @@ -78,28 +78,28 @@ describe "Array#sort" do end it "raises an error when a given block returns nil" do - -> { [1, 2].sort {} }.should raise_error(ArgumentError) + -> { [1, 2].sort {} }.should.raise(ArgumentError) end it "does not call #<=> on contained objects when invoked with a block" do a = Array.new(25) (0...25).each {|i| a[i] = ArraySpecs::UFOSceptic.new } - a.sort { -1 }.should be_an_instance_of(Array) + a.sort { -1 }.should.instance_of?(Array) end it "does not call #<=> on elements when invoked with a block even if Array is large (Rubinius #412)" do a = Array.new(1500) (0...1500).each {|i| a[i] = ArraySpecs::UFOSceptic.new } - a.sort { -1 }.should be_an_instance_of(Array) + a.sort { -1 }.should.instance_of?(Array) end it "completes when supplied a block that always returns the same result" do a = [2, 3, 5, 1, 4] - a.sort { 1 }.should be_an_instance_of(Array) - a.sort { 0 }.should be_an_instance_of(Array) - a.sort { -1 }.should be_an_instance_of(Array) + a.sort { 1 }.should.instance_of?(Array) + a.sort { 0 }.should.instance_of?(Array) + a.sort { -1 }.should.instance_of?(Array) end it "does not freezes self during being sorted" do @@ -136,7 +136,7 @@ describe "Array#sort" do }.should == [-4, 1, 2, 5, 7, 10, 12] -> { a.sort { |n, m| (n - m).to_s } - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "sorts an array that has a value shifted off without a block" do @@ -155,7 +155,7 @@ describe "Array#sort" do it "raises an error if objects can't be compared" do a=[ArraySpecs::Uncomparable.new, ArraySpecs::Uncomparable.new] - -> {a.sort}.should raise_error(ArgumentError) + -> {a.sort}.should.raise(ArgumentError) end # From a strange Rubinius bug @@ -166,7 +166,7 @@ describe "Array#sort" do it "does not return subclass instance on Array subclasses" do ary = ArraySpecs::MyArray[1, 2, 3] - ary.sort.should be_an_instance_of(Array) + ary.sort.should.instance_of?(Array) end end @@ -184,13 +184,13 @@ describe "Array#sort!" do it "returns self if the order of elements changed" do a = [6, 7, 2, 3, 7] - a.sort!.should equal(a) + a.sort!.should.equal?(a) a.should == [2, 3, 6, 7, 7] end it "returns self even if makes no modification" do a = [1, 2, 3, 4, 5] - a.sort!.should equal(a) + a.sort!.should.equal?(a) a.should == [1, 2, 3, 4, 5] end @@ -216,25 +216,25 @@ describe "Array#sort!" do a = Array.new(25) (0...25).each {|i| a[i] = ArraySpecs::UFOSceptic.new } - a.sort! { -1 }.should be_an_instance_of(Array) + a.sort! { -1 }.should.instance_of?(Array) end it "does not call #<=> on elements when invoked with a block even if Array is large (Rubinius #412)" do a = Array.new(1500) (0...1500).each {|i| a[i] = ArraySpecs::UFOSceptic.new } - a.sort! { -1 }.should be_an_instance_of(Array) + a.sort! { -1 }.should.instance_of?(Array) end it "completes when supplied a block that always returns the same result" do a = [2, 3, 5, 1, 4] - a.sort!{ 1 }.should be_an_instance_of(Array) - a.sort!{ 0 }.should be_an_instance_of(Array) - a.sort!{ -1 }.should be_an_instance_of(Array) + a.sort!{ 1 }.should.instance_of?(Array) + a.sort!{ 0 }.should.instance_of?(Array) + a.sort!{ -1 }.should.instance_of?(Array) end it "raises a FrozenError on a frozen array" do - -> { ArraySpecs.frozen_array.sort! }.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.sort! }.should.raise(FrozenError) end it "returns the specified value when it would break in the given block" do @@ -247,6 +247,6 @@ describe "Array#sort!" do ary.sort!{|x,y| break if x==i; x<=>y} ary } - partially_sorted.any?{|ary| ary != [1, 2, 3, 4, 5]}.should be_true + partially_sorted.any?{|ary| ary != [1, 2, 3, 4, 5]}.should == true end end diff --git a/spec/ruby/core/array/sum_spec.rb b/spec/ruby/core/array/sum_spec.rb index 06abe06135..cd4ba4c2d8 100644 --- a/spec/ruby/core/array/sum_spec.rb +++ b/spec/ruby/core/array/sum_spec.rb @@ -60,11 +60,11 @@ describe "Array#sum" do end it 'raises TypeError if any element are not numeric' do - -> { ["a"].sum }.should raise_error(TypeError) + -> { ["a"].sum }.should.raise(TypeError) end it 'raises TypeError if any element cannot be added to init value' do - -> { [1].sum([]) }.should raise_error(TypeError) + -> { [1].sum([]) }.should.raise(TypeError) end it "calls + to sum the elements" do @@ -74,13 +74,11 @@ describe "Array#sum" do [b].sum(a).should == 42 end - ruby_bug '#19530', ''...'3.3' do - it "calls + on the init value" do - a = mock("a") - b = mock("b") - a.should_receive(:+).with(42).and_return(b) - [42].sum(a).should == b - end + it "calls + on the init value" do + a = mock("a") + b = mock("b") + a.should_receive(:+).with(42).and_return(b) + [42].sum(a).should == b end end diff --git a/spec/ruby/core/array/take_spec.rb b/spec/ruby/core/array/take_spec.rb index c4f0ac9aa4..837c734b77 100644 --- a/spec/ruby/core/array/take_spec.rb +++ b/spec/ruby/core/array/take_spec.rb @@ -23,10 +23,10 @@ describe "Array#take" do end it "raises an ArgumentError when the argument is negative" do - ->{ [1].take(-3) }.should raise_error(ArgumentError) + ->{ [1].take(-3) }.should.raise(ArgumentError) end it 'returns a Array instance for Array subclasses' do - ArraySpecs::MyArray[1, 2, 3, 4, 5].take(1).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3, 4, 5].take(1).should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/take_while_spec.rb b/spec/ruby/core/array/take_while_spec.rb index 8f50260b42..7811edab9e 100644 --- a/spec/ruby/core/array/take_while_spec.rb +++ b/spec/ruby/core/array/take_while_spec.rb @@ -16,7 +16,7 @@ describe "Array#take_while" do end it 'returns a Array instance for Array subclasses' do - ArraySpecs::MyArray[1, 2, 3, 4, 5].take_while { |n| n < 4 }.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3, 4, 5].take_while { |n| n < 4 }.should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/to_a_spec.rb b/spec/ruby/core/array/to_a_spec.rb index 49d0a4782e..078de1638a 100644 --- a/spec/ruby/core/array/to_a_spec.rb +++ b/spec/ruby/core/array/to_a_spec.rb @@ -5,12 +5,12 @@ describe "Array#to_a" do it "returns self" do a = [1, 2, 3] a.to_a.should == [1, 2, 3] - a.should equal(a.to_a) + a.should.equal?(a.to_a) end it "does not return subclass instance on Array subclasses" do e = ArraySpecs::MyArray.new(1, 2) - e.to_a.should be_an_instance_of(Array) + e.to_a.should.instance_of?(Array) e.to_a.should == [1, 2] end diff --git a/spec/ruby/core/array/to_ary_spec.rb b/spec/ruby/core/array/to_ary_spec.rb index 314699b709..dc5193158d 100644 --- a/spec/ruby/core/array/to_ary_spec.rb +++ b/spec/ruby/core/array/to_ary_spec.rb @@ -4,9 +4,9 @@ require_relative 'fixtures/classes' describe "Array#to_ary" do it "returns self" do a = [1, 2, 3] - a.should equal(a.to_ary) + a.should.equal?(a.to_ary) a = ArraySpecs::MyArray[1, 2, 3] - a.should equal(a.to_ary) + a.should.equal?(a.to_ary) end it "properly handles recursive arrays" do diff --git a/spec/ruby/core/array/to_h_spec.rb b/spec/ruby/core/array/to_h_spec.rb index 1c814f3d01..1d626763c2 100644 --- a/spec/ruby/core/array/to_h_spec.rb +++ b/spec/ruby/core/array/to_h_spec.rb @@ -25,19 +25,19 @@ describe "Array#to_h" do end it "raises TypeError if an element is not an array" do - -> { [:x].to_h }.should raise_error(TypeError) + -> { [:x].to_h }.should.raise(TypeError) end it "raises ArgumentError if an element is not a [key, value] pair" do - -> { [[:x]].to_h }.should raise_error(ArgumentError) + -> { [[:x]].to_h }.should.raise(ArgumentError) end it "does not accept arguments" do - -> { [].to_h(:a, :b) }.should raise_error(ArgumentError) + -> { [].to_h(:a, :b) }.should.raise(ArgumentError) end it "produces a hash that returns nil for a missing element" do - [[:a, 1], [:b, 2]].to_h[:c].should be_nil + [[:a, 1], [:b, 2]].to_h[:c].should == nil end context "with block" do @@ -54,17 +54,17 @@ describe "Array#to_h" do it "raises ArgumentError if block returns longer or shorter array" do -> do [:a, :b].to_h { |k| [k, k.to_s, 1] } - end.should raise_error(ArgumentError, /wrong array length at 0/) + end.should.raise(ArgumentError, /wrong array length at 0/) -> do [:a, :b].to_h { |k| [k] } - end.should raise_error(ArgumentError, /wrong array length at 0/) + end.should.raise(ArgumentError, /wrong array length at 0/) end it "raises TypeError if block returns something other than Array" do -> do [:a, :b].to_h { |k| "not-array" } - end.should raise_error(TypeError, /wrong element type String at 0/) + end.should.raise(TypeError, /wrong element type String at 0/) end it "coerces returned pair to Array with #to_ary" do @@ -80,7 +80,7 @@ describe "Array#to_h" do -> do [:a].to_h { |k| x } - end.should raise_error(TypeError, /wrong element type MockObject at 0/) + end.should.raise(TypeError, /wrong element type MockObject at 0/) end end end diff --git a/spec/ruby/core/array/transpose_spec.rb b/spec/ruby/core/array/transpose_spec.rb index b39077f4c9..d45e9c351c 100644 --- a/spec/ruby/core/array/transpose_spec.rb +++ b/spec/ruby/core/array/transpose_spec.rb @@ -32,7 +32,7 @@ describe "Array#transpose" do end it "raises a TypeError if the passed Argument does not respond to #to_ary" do - -> { [Object.new, [:a, :b]].transpose }.should raise_error(TypeError) + -> { [Object.new, [:a, :b]].transpose }.should.raise(TypeError) end it "does not call to_ary on array subclass elements" do @@ -41,13 +41,13 @@ describe "Array#transpose" do end it "raises an IndexError if the arrays are not of the same length" do - -> { [[1, 2], [:a]].transpose }.should raise_error(IndexError) + -> { [[1, 2], [:a]].transpose }.should.raise(IndexError) end it "does not return subclass instance on Array subclasses" do result = ArraySpecs::MyArray[ArraySpecs::MyArray[1, 2, 3], ArraySpecs::MyArray[4, 5, 6]].transpose - result.should be_an_instance_of(Array) - result[0].should be_an_instance_of(Array) - result[1].should be_an_instance_of(Array) + result.should.instance_of?(Array) + result[0].should.instance_of?(Array) + result[1].should.instance_of?(Array) end end diff --git a/spec/ruby/core/array/try_convert_spec.rb b/spec/ruby/core/array/try_convert_spec.rb index bea8815006..3eaa0f4b7c 100644 --- a/spec/ruby/core/array/try_convert_spec.rb +++ b/spec/ruby/core/array/try_convert_spec.rb @@ -4,47 +4,47 @@ require_relative 'fixtures/classes' describe "Array.try_convert" do it "returns the argument if it's an Array" do x = Array.new - Array.try_convert(x).should equal(x) + Array.try_convert(x).should.equal?(x) end it "returns the argument if it's a kind of Array" do x = ArraySpecs::MyArray[] - Array.try_convert(x).should equal(x) + Array.try_convert(x).should.equal?(x) end it "returns nil when the argument does not respond to #to_ary" do - Array.try_convert(Object.new).should be_nil + Array.try_convert(Object.new).should == nil end it "sends #to_ary to the argument and returns the result if it's nil" do obj = mock("to_ary") obj.should_receive(:to_ary).and_return(nil) - Array.try_convert(obj).should be_nil + Array.try_convert(obj).should == nil end it "sends #to_ary to the argument and returns the result if it's an Array" do x = Array.new obj = mock("to_ary") obj.should_receive(:to_ary).and_return(x) - Array.try_convert(obj).should equal(x) + Array.try_convert(obj).should.equal?(x) end it "sends #to_ary to the argument and returns the result if it's a kind of Array" do x = ArraySpecs::MyArray[] obj = mock("to_ary") obj.should_receive(:to_ary).and_return(x) - Array.try_convert(obj).should equal(x) + Array.try_convert(obj).should.equal?(x) end it "sends #to_ary to the argument and raises TypeError if it's not a kind of Array" do obj = mock("to_ary") obj.should_receive(:to_ary).and_return(Object.new) - -> { Array.try_convert obj }.should raise_error(TypeError, "can't convert MockObject to Array (MockObject#to_ary gives Object)") + -> { Array.try_convert obj }.should raise_consistent_error(TypeError, "can't convert MockObject into Array (MockObject#to_ary gives Object)") end it "does not rescue exceptions raised by #to_ary" do obj = mock("to_ary") obj.should_receive(:to_ary).and_raise(RuntimeError) - -> { Array.try_convert obj }.should raise_error(RuntimeError) + -> { Array.try_convert obj }.should.raise(RuntimeError) end end diff --git a/spec/ruby/core/array/union_spec.rb b/spec/ruby/core/array/union_spec.rb index ba2cc0d6b7..110894e83d 100644 --- a/spec/ruby/core/array/union_spec.rb +++ b/spec/ruby/core/array/union_spec.rb @@ -15,7 +15,7 @@ describe "Array#union" do end it "does not return subclass instances for Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].union.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].union.should.instance_of?(Array) end it "accepts multiple arguments" do diff --git a/spec/ruby/core/array/uniq_spec.rb b/spec/ruby/core/array/uniq_spec.rb index d5d826db15..0289bee7c2 100644 --- a/spec/ruby/core/array/uniq_spec.rb +++ b/spec/ruby/core/array/uniq_spec.rb @@ -86,7 +86,7 @@ describe "Array#uniq" do end it "returns Array instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].uniq.should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].uniq.should.instance_of?(Array) end it "properly handles an identical item even when its #eql? isn't reflexive" do @@ -138,7 +138,7 @@ describe "Array#uniq!" do it "returns self" do a = [ "a", "a", "b", "b", "c" ] - a.should equal(a.uniq!) + a.should.equal?(a.uniq!) end it "properly handles recursive arrays" do @@ -185,17 +185,17 @@ describe "Array#uniq!" do it "raises a FrozenError on a frozen array when the array is modified" do dup_ary = [1, 1, 2] dup_ary.freeze - -> { dup_ary.uniq! }.should raise_error(FrozenError) + -> { dup_ary.uniq! }.should.raise(FrozenError) end # see [ruby-core:23666] it "raises a FrozenError on a frozen array when the array would not be modified" do - -> { ArraySpecs.frozen_array.uniq!}.should raise_error(FrozenError) - -> { ArraySpecs.empty_frozen_array.uniq!}.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.uniq!}.should.raise(FrozenError) + -> { ArraySpecs.empty_frozen_array.uniq!}.should.raise(FrozenError) end it "doesn't yield to the block on a frozen array" do - -> { ArraySpecs.frozen_array.uniq!{ raise RangeError, "shouldn't yield"}}.should raise_error(FrozenError) + -> { ArraySpecs.frozen_array.uniq!{ raise RangeError, "shouldn't yield"}}.should.raise(FrozenError) end it "compares elements based on the value returned from the block" do diff --git a/spec/ruby/core/array/values_at_spec.rb b/spec/ruby/core/array/values_at_spec.rb index e85bbee400..e11e7e4451 100644 --- a/spec/ruby/core/array/values_at_spec.rb +++ b/spec/ruby/core/array/values_at_spec.rb @@ -59,7 +59,7 @@ describe "Array#values_at" do end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].values_at(0, 1..2, 1).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].values_at(0, 1..2, 1).should.instance_of?(Array) end it "works when given endless ranges" do diff --git a/spec/ruby/core/array/zip_spec.rb b/spec/ruby/core/array/zip_spec.rb index 2a0f64cb49..3ccdf143d6 100644 --- a/spec/ruby/core/array/zip_spec.rb +++ b/spec/ruby/core/array/zip_spec.rb @@ -60,12 +60,12 @@ describe "Array#zip" do end it "does not return subclass instance on Array subclasses" do - ArraySpecs::MyArray[1, 2, 3].zip(["a", "b"]).should be_an_instance_of(Array) + ArraySpecs::MyArray[1, 2, 3].zip(["a", "b"]).should.instance_of?(Array) end it "raises TypeError when some argument isn't Array and doesn't respond to #to_ary and #to_enum" do - -> { [1, 2, 3].zip(Object.new) }.should raise_error(TypeError, "wrong argument type Object (must respond to :each)") - -> { [1, 2, 3].zip(1) }.should raise_error(TypeError, "wrong argument type Integer (must respond to :each)") - -> { [1, 2, 3].zip(true) }.should raise_error(TypeError, "wrong argument type TrueClass (must respond to :each)") + -> { [1, 2, 3].zip(Object.new) }.should.raise(TypeError, "wrong argument type Object (must respond to :each)") + -> { [1, 2, 3].zip(1) }.should.raise(TypeError, "wrong argument type Integer (must respond to :each)") + -> { [1, 2, 3].zip(true) }.should.raise(TypeError, "wrong argument type TrueClass (must respond to :each)") end end |