- TargetRubyVersion: 3.1

-ruby/spec describes the behavior of Ruby 3.1 and more recent Ruby versions.

-More precisely, every latest stable MRI release should [pass](https://.com/ruby/spec/actions/workflows/ci.yml) all specs of ruby/spec (3.1.x, 3.2.x, etc), and those are tested in CI.

- it "padds the output with spaces when the count exceeds the size of the String" do

- it "padds the output with NULL bytes when the count exceeds the size of the String" do

- 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

- it "padds the output with NULL bytes when the count exceeds the size of the String" do

- 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

-ruby_version_is '3.2' do

- describe "Class#attached_object" do

- it "returns the object that is attached to a singleton class" do

- a = Class.new

- a_obj = a.new

- a_obj.singleton_class.attached_object.should == a_obj

- end

- it "returns the class object that is attached to a class's singleton class" do

- a = Class.new

- singleton_class = (class << a; self; end)

- singleton_class.attached_object.should == a

- end

- it "raises TypeError if the class is not a singleton class" do

- a = Class.new

- -> { a.attached_object }.should raise_error(TypeError, /is not a singleton class/)

- end

- it "raises TypeError for special singleton classes" do

- -> { nil.singleton_class.attached_object }.should raise_error(TypeError, /[`']NilClass' is not a singleton class/)

- -> { true.singleton_class.attached_object }.should raise_error(TypeError, /[`']TrueClass' is not a singleton class/)

- -> { false.singleton_class.attached_object }.should raise_error(TypeError, /[`']FalseClass' is not a singleton class/)

- end

- ruby_bug "#19004", ""..."3.2" do

- it "computes the real values of the real & imaginary parts from the polar form" do

- a = Complex.polar(1.0+0.0i, Math::PI/2+0.0i)

- a.real.should be_close(0.0, TOLERANCE)

- a.imag.should be_close(1.0, TOLERANCE)

- a.real.real?.should be_true

- a.imag.real?.should be_true

- b = Complex.polar(1+0.0i)

- b.real.should be_close(1.0, TOLERANCE)

- b.imag.should be_close(0.0, TOLERANCE)

- b.real.real?.should be_true

- b.imag.real?.should be_true

- end

-ruby_version_is ''...'3.2' do

- describe "Data" do

- it "does not exist anymore" do

- Object.should_not have_constant(:Data)

- end

-end

-

-ruby_version_is '3.2' do

- describe "Data" do

- it "is a new constant" do

- Data.superclass.should == Object

- end

- it "is not deprecated" do

- -> { Data }.should_not complain

- end

-ruby_version_is "3.2" do

- describe "Data#deconstruct" do

- it "returns a hash of attributes" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

- d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}

- end

-

- it "requires one argument" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- -> {

- d.deconstruct_keys

- }.should raise_error(ArgumentError, /wrong number of arguments \(given 0, expected 1\)/)

- end

-

- it "returns only specified keys" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}

- d.deconstruct_keys([:x] ).should == {x: 1}

- d.deconstruct_keys([] ).should == {}

- end

-

- it "accepts string attribute names" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

- d.deconstruct_keys(['x', 'y']).should == {'x' => 1, 'y' => 2}

- end

-

- it "accepts argument position number as well but returns them as keys" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([0, 1]).should == {0 => 1, 1 => 2}

- d.deconstruct_keys([0] ).should == {0 => 1}

- d.deconstruct_keys([-1] ).should == {-1 => 2}

- end

-

- it "ignores incorrect position numbers" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([0, 3]).should == {0 => 1}

- end

-

- it "support mixing attribute names and argument position numbers" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([0, :x]).should == {0 => 1, :x => 1}

- end

-

- it "returns an empty hash when there are more keys than attributes" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

- d.deconstruct_keys([:x, :y, :x]).should == {}

- end

-

- it "returns at first not existing attribute name" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([:a, :x]).should == {}

- d.deconstruct_keys([:x, :a]).should == {x: 1}

- end

-

- it "returns at first not existing argument position number" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys([3, 0]).should == {}

- d.deconstruct_keys([0, 3]).should == {0 => 1}

- end

-

- it "accepts nil argument and return all the attributes" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- d.deconstruct_keys(nil).should == {x: 1, y: 2}

- end

-

- it "raises TypeError if index is not a String, a Symbol and not convertible to Integer " do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- -> {

- d.deconstruct_keys([0, []])

- }.should raise_error(TypeError, "no implicit conversion of Array into Integer")

- end

-

- it "raise TypeError if passed anything except nil or array" do

- klass = Data.define(:x, :y)

- d = klass.new(1, 2)

-

- -> { d.deconstruct_keys('x') }.should raise_error(TypeError, /expected Array or nil/)

- -> { d.deconstruct_keys(1) }.should raise_error(TypeError, /expected Array or nil/)

- -> { d.deconstruct_keys(:x) }.should raise_error(TypeError, /expected Array or nil/)

- -> { d.deconstruct_keys({}) }.should raise_error(TypeError, /expected Array or nil/)

- end

-ruby_version_is "3.2" do

- describe "Data#deconstruct" do

- it "returns an array of attribute values" do

- DataSpecs::Measure.new(42, "km").deconstruct.should == [42, "km"]

- end

-ruby_version_is "3.2" do

- describe "Data.define" do

- it "accepts no arguments" do

- empty_data = Data.define

- empty_data.members.should == []

- end

- it "accepts symbols" do

- movie = Data.define(:title, :year)

- movie.members.should == [:title, :year]

- end

- it "accepts strings" do

- movie = Data.define("title", "year")

- movie.members.should == [:title, :year]

- end

- it "accepts a mix of strings and symbols" do

- movie = Data.define("title", :year, "genre")

- movie.members.should == [:title, :year, :genre]

- end

- it "accepts a block" do

- movie = Data.define(:title, :year) do

- def title_with_year

- "#{title} (#{year})"

- end

- movie.members.should == [:title, :year]

- movie.new("Matrix", 1999).title_with_year.should == "Matrix (1999)"

-ruby_version_is "3.2" do

- describe "Data#eql?" do

- it "returns true if the other is the same object" do

- a = DataSpecs::Measure.new(42, "km")

- a.should.eql?(a)

- end

- it "returns true if the other has all the same fields" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "km")

- a.should.eql?(b)

- end

- it "returns false if the other is a different object or has different fields" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "mi")

- a.should_not.eql?(b)

- end

- it "returns false if other is of a different class" do

- a = DataSpecs::Measure.new(42, "km")

- klass = Data.define(*DataSpecs::Measure.members)

- b = klass.new(42, "km")

- a.should_not.eql?(b)

- end

- it "returns false if any corresponding elements are not equal with #eql?" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42.0, "mi")

- a.should_not.eql?(b)

- end

- context "recursive structure" do

- it "returns true the other is the same object" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: 42, unit: a)

- a.should.eql?(a)

- end

- it "returns true if the other has all the same fields" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: 42, unit: a)

- b = DataSpecs::Measure.allocate

- b.send(:initialize, amount: 42, unit: b)

- a.should.eql?(b)

- end

- it "returns false if any corresponding elements are not equal with #eql?" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: a, unit: "km")

- b = DataSpecs::Measure.allocate

- b.send(:initialize, amount: b, unit: "mi")

- a.should_not.eql?(b)

- end

-ruby_version_is "3.2" do

- describe "Data#==" do

- it "returns true if the other is the same object" do

- a = DataSpecs::Measure.new(42, "km")

- a.should == a

- end

- it "returns true if the other has all the same fields" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "km")

- a.should == b

- end

- it "returns false if the other is a different object or has different fields" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "mi")

- a.should_not == b

- end

- it "returns false if other is of a different class" do

- a = DataSpecs::Measure.new(42, "km")

- klass = Data.define(*DataSpecs::Measure.members)

- b = klass.new(42, "km")

- a.should_not == b

- end

- it "returns false if any corresponding elements are not equal with #==" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42.0, "mi")

- a.should_not == b

- end

- context "recursive structure" do

- it "returns true the other is the same object" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: 42, unit: a)

- a.should == a

- end

- it "returns true if the other has all the same fields" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: 42, unit: a)

- b = DataSpecs::Measure.allocate

- b.send(:initialize, amount: 42, unit: b)

- a.should == b

- end

- it "returns false if any corresponding elements are not equal with #==" do

- a = DataSpecs::Measure.allocate

- a.send(:initialize, amount: a, unit: "km")

- b = DataSpecs::Measure.allocate

- b.send(:initialize, amount: b, unit: "mi")

- a.should_not == b

- end

- guard -> { ruby_version_is "3.2" and Data.respond_to?(:define) } do

-ruby_version_is "3.2" do

- describe "Data#hash" do

- it "returns the same integer for objects with the same content" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "km")

- a.hash.should == b.hash

- a.hash.should be_an_instance_of(Integer)

- end

- it "returns different hashes for objects with different values" do

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(42, "ml")

- a.hash.should_not == b.hash

- a = DataSpecs::Measure.new(42, "km")

- b = DataSpecs::Measure.new(13, "km")

- a.hash.should_not == b.hash

- end

- it "returns different hashes for different classes" do

- Data.define(:x).new(1).hash.should != Data.define(:x).new(1).hash

- end

-ruby_version_is "3.2" do

- describe "Data#initialize" do

- it "accepts positional arguments" do

- data = DataSpecs::Measure.new(42, "km")

- data.amount.should == 42

- data.unit.should == "km"

- end

- it "accepts alternative positional arguments" do

- data = DataSpecs::Measure[42, "km"]

- data.amount.should == 42

- data.unit.should == "km"

- end

- it "accepts keyword arguments" do

- data = DataSpecs::Measure.new(amount: 42, unit: "km")

- data.amount.should == 42

- data.unit.should == "km"

- end

- it "accepts alternative keyword arguments" do

- data = DataSpecs::Measure[amount: 42, unit: "km"]

- data.amount.should == 42

- data.unit.should == "km"

- end

- it "accepts String keyword arguments" do

- data = DataSpecs::Measure.new("amount" => 42, "unit" => "km")

- data.amount.should == 42

- data.unit.should == "km"

- end

- it "raises ArgumentError if no arguments are given" do

- -> {

- DataSpecs::Measure.new

- }.should raise_error(ArgumentError) { |e|

- e.message.should.include?("missing keywords: :amount, :unit")

- }

- end

- it "raises ArgumentError if at least one argument is missing" do

- -> {

- DataSpecs::Measure.new(unit: "km")

- }.should raise_error(ArgumentError) { |e|

- e.message.should.include?("missing keyword: :amount")

- }

- end

- it "raises ArgumentError if unknown keyword is given" do

- -> {

- DataSpecs::Measure.new(amount: 42, unit: "km", system: "metric")

- }.should raise_error(ArgumentError) { |e|

- e.message.should.include?("unknown keyword: :system")

- }

- end

-ruby_version_is "3.2" do

- describe "Data#inspect" do

- it_behaves_like :data_inspect, :inspect

- end

-ruby_version_is "3.2" do

- describe "Data#members" do

- it "returns an array of attribute names" do

- measure = DataSpecs::Measure.new(amount: 42, unit: 'km')

- measure.members.should == [:amount, :unit]

- end

- describe "DataClass#members" do

- it "returns an array of attribute names" do

- DataSpecs::Measure.members.should == [:amount, :unit]

- end

- context "class inheriting Data" do

- it "isn't available in a subclass" do

- DataSpecs::DataSubclass.should_not.respond_to?(:members)

- end

-ruby_version_is "3.2" do

- describe "Data#to_h" do

- it "transforms the data object into a hash" do

- data.to_h.should == { amount: 42, unit: 'km' }

- context "with block" do

- it "transforms [key, value] pairs returned by the block into a hash" do

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- data.to_h { |key, value| [value, key] }.should == { 42 => :amount, 'km' => :unit }

- end

-

- it "passes to a block each pair's key and value as separate arguments" do

- ScratchPad.record []

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- data.to_h { |k, v| ScratchPad << [k, v]; [k, v] }

- ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]

- ScratchPad.record []

- data.to_h { |*args| ScratchPad << args; [args[0], args[1]] }

- ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]

- end

- it "raises ArgumentError if block returns longer or shorter array" do

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- -> do

- data.to_h { |k, v| [k.to_s, v*v, 1] }

- end.should raise_error(ArgumentError, /element has wrong array length/)

- -> do

- data.to_h { |k, v| [k] }

- end.should raise_error(ArgumentError, /element has wrong array length/)

- end

- it "raises TypeError if block returns something other than Array" do

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- -> do

- data.to_h { |k, v| "not-array" }

- end.should raise_error(TypeError, /wrong element type String/)

- end

- it "coerces returned pair to Array with #to_ary" do

- x = mock('x')

- x.stub!(:to_ary).and_return([:b, 'b'])

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- data.to_h { |k| x }.should == { :b => 'b' }

- end

- it "does not coerce returned pair to Array with #to_a" do

- x = mock('x')

- x.stub!(:to_a).and_return([:b, 'b'])

- data = DataSpecs::Measure.new(amount: 42, unit: 'km')

- -> do

- data.to_h { |k| x }

- end.should raise_error(TypeError, /wrong element type MockObject/)

- end

-ruby_version_is "3.2" do

- describe "Data#to_s" do

- it_behaves_like :data_inspect, :to_s

- end

-ruby_version_is "3.2" do

- describe "Data#with" do

- it "returns self if given no arguments" do

- data = DataSpecs::Measure.new(amount: 42, unit: "km")

- data = data.with.should.equal?(data)

- end

- it "accepts keyword arguments" do

- data = DataSpecs::Measure.new(amount: 42, unit: "km")

- data = data.with(amount: 4, unit: "m")

- data.amount.should == 4

- data.unit.should == "m"

- end

- it "accepts String keyword arguments" do

- data = DataSpecs::Measure.new(amount: 42, unit: "km")

- data = data.with("amount" => 4, "unit" => "m")

- data.amount.should == 4

- data.unit.should == "m"

- end

- it "raises ArgumentError if no keyword arguments are given" do

- data = DataSpecs::Measure.new(amount: 42, unit: "km")

- -> {

- data.with(4, "m")

- }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")

- end

- guard -> { Dir.respond_to? :fchdir } do

- guard -> { dir.respond_to? :fileno } do

- guard -> { Dir.respond_to? :for_fd } do

- guard -> { Dir.respond_to? :for_fd } do

-ruby_version_is "3.2" do

- describe "Dir.exists?" do

- it "has been removed" do

- Dir.should_not.respond_to?(:exists?)

- end

- guard -> { Dir.respond_to? :fchdir } do

- guard_not -> { Dir.respond_to? :fchdir } do

- if RUBY_VERSION > '3.1'

- def self.expected_glob_paths

- expected_paths - ['..']

- end

- else

- def self.expected_glob_paths

- expected_paths

- end

- guard -> { Dir.respond_to? :for_fd } do

- guard_not -> { Dir.respond_to? :for_fd } do

- ruby_version_is "3.2" do

- it "returns the home directory with forward slashs and as UTF-8" do

- ENV['HOME'] = "C:\\rubyspäc\\home"

- home = Dir.home

- home.should == "C:/rubyspäc/home"

- home.encoding.should == Encoding::UTF_8

- end

- it "retrieves the directory from HOME, USERPROFILE, HOMEDRIVE/HOMEPATH and the WinAPI in that order" do

- old_dirs = [ENV.delete('HOME'), ENV.delete('USERPROFILE'), ENV.delete('HOMEDRIVE'), ENV.delete('HOMEPATH')]

- Dir.home.should == old_dirs[1].gsub("\\", "/")

- ENV['HOMEDRIVE'] = "C:"

- ENV['HOMEPATH'] = "\\rubyspec\\home1"

- Dir.home.should == "C:/rubyspec/home1"

- ENV['USERPROFILE'] = "C:\\rubyspec\\home2"

- Dir.home.should == "C:/rubyspec/home2"

- ENV['HOME'] = "C:\\rubyspec\\home3"

- Dir.home.should == "C:/rubyspec/home3"

- ensure

- ENV['HOME'], ENV['USERPROFILE'], ENV['HOMEDRIVE'], ENV['HOMEPATH'] = *old_dirs

- end

- ruby_version_is "3.2"..."3.3" do

- # Set is a core class since Ruby 3.2

- ruby_version_is '3.2' do

- class SetSubclass < Set

- end

- ruby_bug '#18635', ''...'3.2' do

- it "raises an ArgumentError when no parameters or block is given" do

- -> { [1,2].send(@method) }.should raise_error(ArgumentError)

- -> { {one: 1, two: 2}.send(@method) }.should raise_error(ArgumentError)

- end

-ruby_version_is "3.2" do

- describe "Enumerable#to_set" do

- it "returns a new Set created from self" do

- [1, 2, 3].to_set.should == Set[1, 2, 3]

- {a: 1, b: 2}.to_set.should == Set[[:b, 2], [:a, 1]]

- end

- it "passes down passed blocks" do

- [1, 2, 3].to_set { |x| x * x }.should == Set[1, 4, 9]

- end

- it "instantiates an object of provided as the first argument set class" do

- set = [1, 2, 3].to_set(EnumerableSpecs::SetSubclass)

- set.should be_kind_of(EnumerableSpecs::SetSubclass)

- set.to_a.sort.should == [1, 2, 3]

- end

- it "does not need explicit `require 'set'`" do

- output = ruby_exe(<<~RUBY, options: '--disable-gems', args: '2>&1')

- puts [1, 2, 3].to_set

- RUBY

- output.chomp.should == "#<Set: {1, 2, 3}>"

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#each" do

- it_behaves_like :enumeratorized_with_origin_size, :each, Enumerator::Product.new([1, 2], [:a, :b])

- it "yields each element of Cartesian product of enumerators" do

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- acc = []

- enum.each { |e| acc << e }

- acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

-

- it "calls #each_entry method on enumerators" do

- object1 = Object.new

- def object1.each_entry

- yield 1

- yield 2

- end

-

- object2 = Object.new

- def object2.each_entry

- yield :a

- yield :b

- end

- enum = Enumerator::Product.new(object1, object2)

- acc = []

- enum.each { |e| acc << e }

- acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- it "raises a NoMethodError if the object doesn't respond to #each_entry" do

- -> {

- Enumerator::Product.new(Object.new).each {}

- }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)

- it "returns enumerator if not given a block" do

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- enum.each.should.kind_of?(Enumerator)

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

- it "returns self if given a block" do

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- enum.each {}.should.equal?(enum)

- end

- it "doesn't accept arguments" do

- Enumerator::Product.instance_method(:each).arity.should == 0

- end

- it "yields each element to a block that takes multiple arguments" do

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- acc = []

- enum.each { |x, y| acc << x }

- acc.should == [1, 1, 2, 2]

- acc = []

- enum.each { |x, y| acc << y }

- acc.should == [:a, :b, :a, :b]

- acc = []

- enum.each { |x, y, z| acc << z }

- acc.should == [nil, nil, nil, nil]

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#initialize_copy" do

- it "replaces content of the receiver with content of the other object" do

- enum = Enumerator::Product.new([true, false])

- enum2 = Enumerator::Product.new([1, 2], [:a, :b])

- enum.send(:initialize_copy, enum2)

- enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

- it "returns self" do

- enum = Enumerator::Product.new([true, false])

- enum2 = Enumerator::Product.new([1, 2], [:a, :b])

- enum.send(:initialize_copy, enum2).should.equal?(enum)

- end

- it "is a private method" do

- Enumerator::Product.should have_private_instance_method(:initialize_copy, false)

- end

- it "does nothing if the argument is the same as the receiver" do

- enum = Enumerator::Product.new(1..2)

- enum.send(:initialize_copy, enum).should.equal?(enum)

- enum.freeze

- enum.send(:initialize_copy, enum).should.equal?(enum)

- end

- it "raises FrozenError if the receiver is frozen" do

- enum = Enumerator::Product.new(1..2)

- enum2 = Enumerator::Product.new(3..4)

- -> { enum.freeze.send(:initialize_copy, enum2) }.should raise_error(FrozenError)

- end

- it "raises TypeError if the objects are of different class" do

- enum = Enumerator::Product.new(1..2)

- enum2 = Class.new(Enumerator::Product).new(3..4)

- -> { enum.send(:initialize_copy, enum2) }.should raise_error(TypeError, 'initialize_copy should take same class object')

- -> { enum2.send(:initialize_copy, enum) }.should raise_error(TypeError, 'initialize_copy should take same class object')

- end

- it "raises ArgumentError if the argument is not initialized yet" do

- enum = Enumerator::Product.new(1..2)

- enum2 = Enumerator::Product.allocate

- -> { enum.send(:initialize_copy, enum2) }.should raise_error(ArgumentError, 'uninitialized product')

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#initialize" do

- before :each do

- @uninitialized = Enumerator::Product.allocate

- end

- it "is a private method" do

- Enumerator::Product.should have_private_instance_method(:initialize, false)

- end

- it "returns self" do

- @uninitialized.send(:initialize).should equal(@uninitialized)

- end

- it "accepts many arguments" do

- @uninitialized.send(:initialize, 0..1, 2..3, 4..5).should equal(@uninitialized)

- end

- it "accepts arguments that are not Enumerable nor responding to :each_entry" do

- @uninitialized.send(:initialize, Object.new).should equal(@uninitialized)

- end

- describe "on frozen instance" do

- it "raises a FrozenError" do

- -> {

- @uninitialized.freeze.send(:initialize, 0..1)

- }.should raise_error(FrozenError)

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#inspect" do

- it "returns a String including enumerators" do

- enum = Enumerator::Product.new([1, 2], [:a, :b])

- enum.inspect.should == "#<Enumerator::Product: [[1, 2], [:a, :b]]>"

- end

- it "represents a recursive element with '[...]'" do

- enum = [1, 2]

- enum_recursive = Enumerator::Product.new(enum)

- enum << enum_recursive

- enum_recursive.inspect.should == "#<Enumerator::Product: [[1, 2, #<Enumerator::Product: ...>]]>"

- end

- it "returns a not initialized representation if #initialized is not called yet" do

- Enumerator::Product.allocate.inspect.should == "#<Enumerator::Product: uninitialized>"

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#rewind" do

- before :each do

- @enum = Enumerator::Product.new([1, 2].each.to_enum, [:a, :b].each.to_enum)

- end

- it "resets the enumerator to its initial state" do

- @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- @enum.rewind

- @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

- it "returns self" do

- @enum.rewind.should.equal? @enum

- end

- it "has no effect on a new enumerator" do

- @enum.rewind

- @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

- it "has no effect if called multiple, consecutive times" do

- @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- @enum.rewind

- @enum.rewind

- @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]

- end

- it "calls the enclosed object's rewind method if one exists" do

- obj = mock('rewinder')

- enum = Enumerator::Product.new(obj.to_enum)

- obj.should_receive(:rewind)

- enum.rewind

- end

- it "does nothing if the object doesn't have a #rewind method" do

- obj = mock('rewinder')

- enum = Enumerator::Product.new(obj.to_enum)

- enum.rewind.should == enum

- end

- it "calls a rewind method on each enumerable in direct order" do

- ScratchPad.record []

- object1 = Object.new

- def object1.rewind; ScratchPad << :object1; end

- object2 = Object.new

- def object2.rewind; ScratchPad << :object2; end

- object3 = Object.new

- def object3.rewind; ScratchPad << :object3; end

- enum = Enumerator::Product.new(object1, object2, object3)

- enum.rewind

- ScratchPad.recorded.should == [:object1, :object2, :object3]

- end

-ruby_version_is "3.2" do

- describe "Enumerator::Product#size" do

- it "returns the total size of the enumerator product calculated by multiplying the sizes of enumerables in the product" do

- product = Enumerator::Product.new(1..2, 1..3, 1..4)

- product.size.should == 24 # 2 * 3 * 4

- end

-

- it "returns nil if any enumerable reports its size as nil" do

- enum = Object.new

- def enum.size; nil; end

-

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == nil

- end

-

- it "returns Float::INFINITY if any enumerable reports its size as Float::INFINITY" do

- enum = Object.new

- def enum.size; Float::INFINITY; end

-

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == Float::INFINITY

- end

-

- it "returns nil if any enumerable reports its size as Float::NAN" do

- enum = Object.new

- def enum.size; Float::NAN; end

-

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == nil

- end

-

- it "returns nil if any enumerable doesn't respond to #size" do

- enum = Object.new

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == nil

- end

-

- it "returns nil if any enumerable reports a not-convertible to Integer" do

- enum = Object.new

- def enum.size; :symbol; end

-

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == nil

- end

-

- it "returns nil if any enumerable reports a non-Integer but convertible to Integer size" do

- enum = Object.new

- def enum.size; 1.0; end

-

- product = Enumerator::Product.new(1..2, enum)

- product.size.should == nil

- end

-ruby_version_is "3.2" do

- describe "Enumerator.product" do

- it "returns a Cartesian product of enumerators" do

- enum = Enumerator.product(1..2, ["A", "B"])

- enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]

- end

-

- it "accepts a list of enumerators of any length" do

- enum = Enumerator.product(1..2)

- enum.to_a.should == [[1], [2]]

- enum = Enumerator.product(1..2, ["A"])

- enum.to_a.should == [[1, "A"], [2, "A"]]

- enum = Enumerator.product(1..2, ["A"], ["B"])

- enum.to_a.should == [[1, "A", "B"], [2, "A", "B"]]

- enum = Enumerator.product(2..3, ["A"], ["B"], ["C"])

- enum.to_a.should == [[2, "A", "B", "C"], [3, "A", "B", "C"]]

- end

- it "returns an enumerator with an empty array when no arguments passed" do

- enum = Enumerator.product

- enum.to_a.should == [[]]

- end

- it "returns an instance of Enumerator::Product" do

- enum = Enumerator.product

- enum.class.should == Enumerator::Product

- end

- it "accepts infinite enumerators and returns infinite enumerator" do

- enum = Enumerator.product(1.., ["A", "B"])

- enum.take(5).should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"], [3, "A"]]

- enum.size.should == Float::INFINITY

- end

- it "accepts a block" do

- elems = []

- enum = Enumerator.product(1..2, ["X", "Y"]) { elems << _1 }

- elems.should == [[1, "X"], [1, "Y"], [2, "X"], [2, "Y"]]

- end

- it "returns nil when a block passed" do

- Enumerator.product(1..2) {}.should == nil

- end

- # https://bugs.ruby-lang.org/issues/19829

- it "reject keyword arguments" do

- -> {

- Enumerator.product(1..3, foo: 1, bar: 2)

- }.should raise_error(ArgumentError, "unknown keywords: :foo, :bar")

- end

- it "calls only #each_entry method on arguments" do

- object = Object.new

- def object.each_entry

- yield 1

- yield 2

- end

- enum = Enumerator.product(object, ["A", "B"])

- enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]

- it "raises NoMethodError when argument doesn't respond to #each_entry" do

- -> {

- Enumerator.product(Object.new).to_a

- }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)

- end

- it "calls #each_entry lazily" do

- Enumerator.product(Object.new).should be_kind_of(Enumerator)

- end

- it "iterates through consuming enumerator elements only once" do

- a = [1, 2, 3]

- i = 0

- enum = Enumerator.new do |y|

- while i < a.size

- y << a[i]

- i += 1

- end

-

- Enumerator.product(['a', 'b'], enum).to_a.should == [["a", 1], ["a", 2], ["a", 3]]

- ruby_version_is "3.2" do

- it "raises TypeError" do

- -> {

- ENV.clone

- }.should raise_error(TypeError, /Cannot clone ENV, use ENV.to_h to get a copy of ENV as a hash/)

- end

- ruby_version_is "3.2" do

- it "adds the multiple parameter hashes to ENV, returning ENV" do

- ENV.send(@method, {"foo" => "multi1"}, {"bar" => "multi2"}).should equal(ENV)

- ENV["foo"].should == "multi1"

- ENV["bar"].should == "multi2"

- end

- ruby_version_is "3.2" do

- it "returns decorated message" do

- RuntimeError.new("new error").detailed_message.should == "new error (RuntimeError)"

- end

- it "is called by #full_message to allow message customization" do

- exception = Exception.new("new error")

- def exception.detailed_message(**)

- "<prefix>#{message}<suffix>"

- end

- exception.full_message(highlight: false).should.include? "<prefix>new error<suffix>"

- it "returns just a message if exception class is anonymous" do

- Class.new(RuntimeError).new("message").detailed_message.should == "message"

- end

- it "returns 'unhandled exception' for an instance of RuntimeError with empty message" do

- RuntimeError.new("").detailed_message.should == "unhandled exception"

- end

- it "returns just class name for an instance other than RuntimeError with empty message" do

- DetailedMessageSpec::C.new("").detailed_message.should == "DetailedMessageSpec::C"

- StandardError.new("").detailed_message.should == "StandardError"

- end

- it "returns a generated class name for an instance of RuntimeError anonymous subclass with empty message" do

- klass = Class.new(RuntimeError)

- klass.new("").detailed_message.should =~ /\A#<Class:0x\h+>\z/

- end

- it "accepts highlight keyword argument and adds escape control sequences" do

- RuntimeError.new("new error").detailed_message(highlight: true).should == "\e[1mnew error (\e[1;4mRuntimeError\e[m\e[1m)\e[m"

- end

- it "accepts highlight keyword argument and adds escape control sequences for an instance of RuntimeError with empty message" do

- RuntimeError.new("").detailed_message(highlight: true).should == "\e[1;4munhandled exception\e[m"

- end

- it "accepts highlight keyword argument and adds escape control sequences for an instance other than RuntimeError with empty message" do

- StandardError.new("").detailed_message(highlight: true).should == "\e[1;4mStandardError\e[m"

- end

- it "allows and ignores other keyword arguments" do

- RuntimeError.new("new error").detailed_message(foo: true).should == "new error (RuntimeError)"

- end

- ruby_version_is "3.2" do

- it "relies on #detailed_message" do

- e = RuntimeError.new("new error")

- e.define_singleton_method(:detailed_message) { |**| "DETAILED MESSAGE" }

- e.full_message.lines.first.should =~ /DETAILED MESSAGE/

- end

-

- it "passes all its own keyword arguments (with :highlight default value and without :order default value) to #detailed_message" do

- e = RuntimeError.new("new error")

- options_passed = nil

- e.define_singleton_method(:detailed_message) do |**options|

- options_passed = options

- "DETAILED MESSAGE"

- end

- e.full_message(foo: "bar")

- options_passed.should == { foo: "bar", highlight: Exception.to_tty? }

- it "converts #detailed_message returned value to String if it isn't a String" do

- message = Object.new

- def message.to_str; "DETAILED MESSAGE"; end

- e = RuntimeError.new("new error")

- e.define_singleton_method(:detailed_message) { |**| message }

- e.full_message.lines.first.should =~ /DETAILED MESSAGE/

- end

- it "uses class name if #detailed_message returns nil" do

- e = RuntimeError.new("new error")

- e.define_singleton_method(:detailed_message) { |**| nil }

- e.full_message(highlight: false).lines.first.should =~ /RuntimeError/

- e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/

- end

- it "uses class name if exception object doesn't respond to #detailed_message" do

- e = RuntimeError.new("new error")

- class << e

- undef :detailed_message

- end

- e.full_message(highlight: false).lines.first.should =~ /RuntimeError/

- e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/

-ruby_version_is "3.2" do

- describe "SyntaxError#path" do

- it "returns the file path provided to eval" do

- filename = "speccing.rb"

- -> {

- eval("if true", TOPLEVEL_BINDING, filename)

- }.should raise_error(SyntaxError) { |e|

- e.path.should == filename

- }

- end

- it "returns the file path that raised an exception" do

- expected_path = fixture(__FILE__, "syntax_error.rb")

- -> {

- require_relative "fixtures/syntax_error"

- }.should raise_error(SyntaxError) { |e| e.path.should == expected_path }

- end

- it "returns nil when constructed directly" do

- SyntaxError.new.path.should == nil

- end

-ruby_version_is "3.2" do

- describe "Fiber.blocking" do

- context "when fiber is non-blocking" do

- it "can become blocking" do

- fiber = Fiber.new(blocking: false) do

- Fiber.blocking do |f|

- f.blocking? ? :blocking : :non_blocking

- end

-

- blocking = fiber.resume

- blocking.should == :blocking

-ruby_version_is "3.2" do

- describe "Fiber.new(storage:)" do

- it "creates a Fiber with the given storage" do

- storage = {life: 42}

- fiber = Fiber.new(storage: storage) { Fiber.current.storage }

- fiber.resume.should == storage

- end

- it "creates a fiber with lazily initialized storage" do

- Fiber.new(storage: nil) { Fiber[:x] = 10; Fiber.current.storage }.resume.should == {x: 10}

- end

- it "creates a fiber by inheriting the storage of the parent fiber" do

- fiber = Fiber.new(storage: {life: 42}) do

- Fiber.new { Fiber.current.storage }.resume

- end

- fiber.resume.should == {life: 42}

- it "cannot create a fiber with non-hash storage" do

- -> { Fiber.new(storage: 42) {} }.should raise_error(TypeError)

- end

- it "cannot create a fiber with a frozen hash as storage" do

- -> { Fiber.new(storage: {life: 43}.freeze) {} }.should raise_error(FrozenError)

- end

- it "cannot create a fiber with a storage hash with non-symbol keys" do

- -> { Fiber.new(storage: {life: 43, Object.new => 44}) {} }.should raise_error(TypeError)

- end

- describe "Fiber#storage" do

- it "cannot be accessed from a different fiber" do

- f = Fiber.new(storage: {life: 42}) { nil }

- -> {

- f.storage

- }.should raise_error(ArgumentError, /Fiber storage can only be accessed from the Fiber it belongs to/)

- end

- describe "Fiber#storage=" do

- it "can clear the storage of the fiber" do

- fiber = Fiber.new(storage: {life: 42}) do

- Fiber.current.storage = nil

- Fiber[:x] = 10

- Fiber.current.storage

- end

- fiber.resume.should == {x: 10}

- it "can set the storage of the fiber" do

- fiber = Fiber.new(storage: {life: 42}) do

- Fiber.current.storage = {life: 43}

- Fiber.current.storage

- end

- fiber.resume.should == {life: 43}

- it "can't set the storage of the fiber to non-hash" do

- -> { Fiber.current.storage = 42 }.should raise_error(TypeError)

- end

- it "can't set the storage of the fiber to a frozen hash" do

- -> { Fiber.current.storage = {life: 43}.freeze }.should raise_error(FrozenError)

- end

- it "can't set the storage of the fiber to a hash with non-symbol keys" do

- -> { Fiber.current.storage = {life: 43, Object.new => 44} }.should raise_error(TypeError)

- end

- describe "Fiber.[]" do

- it "returns the value of the given key in the storage of the current fiber" do

- Fiber.new(storage: {life: 42}) { Fiber[:life] }.resume.should == 42

- end

- it "returns nil if the key is not present in the storage of the current fiber" do

- Fiber.new(storage: {life: 42}) { Fiber[:death] }.resume.should be_nil

- end

- it "returns nil if the current fiber has no storage" do

- Fiber.new { Fiber[:life] }.resume.should be_nil

- ruby_version_is "3.2.3" do

- it "can use dynamically defined keys" do

- key = :"#{self.class.name}#.#{self.object_id}"

- Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42

- end

-

- it "can't use invalid keys" do

- invalid_keys = [Object.new, 12]

- invalid_keys.each do |key|

- -> { Fiber[key] }.should raise_error(TypeError)

- end

- end

- ruby_bug "#20978", "3.2"..."3.4" do

- it "can use keys as strings" do

- key = Object.new

- def key.to_str; "Foo"; end

- Fiber.new { Fiber[key] = 42; Fiber["Foo"] }.resume.should == 42

- end

-

- it "converts a String key into a Symbol" do

- Fiber.new { Fiber["key"] = 42; Fiber[:key] }.resume.should == 42

- Fiber.new { Fiber[:key] = 42; Fiber["key"] }.resume.should == 42

- end

-

- it "can use any object that responds to #to_str as a key" do

- key = mock("key")

- key.should_receive(:to_str).twice.and_return("key")

- Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42

- end

- it "does not call #to_sym on the key" do

- key.should_not_receive(:to_sym)

- -> { Fiber[key] }.should raise_error(TypeError)

- it "can access the storage of the parent fiber" do

- f = Fiber.new(storage: {life: 42}) do

- Fiber.new { Fiber[:life] }.resume

- end

- f.resume.should == 42

- end

- it "can't access the storage of the fiber with non-symbol keys" do

- -> { Fiber[Object.new] }.should raise_error(TypeError)

- describe "Fiber.[]=" do

- it "sets the value of the given key in the storage of the current fiber" do

- Fiber.new(storage: {life: 42}) { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43

- end

- it "sets the value of the given key in the storage of the current fiber" do

- Fiber.new(storage: {life: 42}) { Fiber[:death] = 43; Fiber[:death] }.resume.should == 43

- end

- it "sets the value of the given key in the storage of the current fiber" do

- Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43

- end

- it "does not overwrite the storage of the parent fiber" do

- f = Fiber.new(storage: {life: 42}) do

- Fiber.yield Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume

- Fiber[:life]

- end

- f.resume.should == 43 # Value of the inner fiber

- f.resume.should == 42 # Value of the outer fiber

- end

- it "can't access the storage of the fiber with non-symbol keys" do

- -> { Fiber[Object.new] = 44 }.should raise_error(TypeError)

- ruby_version_is "3.3" do

- it "deletes the fiber storage key when assigning nil" do

- Fiber.new(storage: {life: 42}) {

- Fiber[:life] = nil

- Fiber.current.storage

- }.resume.should == {}

- end

- describe "Thread.new" do

- it "creates a thread with the storage of the current fiber" do

- fiber = Fiber.new(storage: {life: 42}) do

- Thread.new { Fiber.current.storage }.value

- end

- fiber.resume.should == {life: 42}

-ruby_version_is "3.2" do

- describe "File.exists?" do

- it "has been removed" do

- File.should_not.respond_to?(:exists?)

- end

-ruby_version_is "3.2" do

- describe "FileTest.exists?" do

- it "has been removed" do

- FileTest.should_not.respond_to?(:exists?)

- end

- ruby_version_is '3.2' do

- it "returns nil if the Hash is empty" do

- h = {}

- def h.default(key)

- raise

- end

- h.shift.should == nil

- end

- end

-

- ruby_version_is ''...'3.2' do

- it "calls #default with nil if the Hash is empty" do

- h = {}

- def h.default(key)

- key.should == nil

- :foo

- end

- h.shift.should == :foo

- ruby_version_is '3.2' do

- it "returns nil for empty hashes with defaults and default procs" do

- Hash.new(5).shift.should == nil

- h = Hash.new { |*args| args }

- h.shift.should == nil

- end

- end

-

- ruby_version_is ''...'3.2' do

- it "returns (computed) default for empty hashes" do

- Hash.new(5).shift.should == 5

- h = Hash.new { |*args| args }

- h.shift.should == [h, nil]

- end

- ruby_version_is '3.2' do

- it "returns a quotient of division which is rounded up to the nearest integer" do

- 0.ceildiv(3).should eql(0)

- 1.ceildiv(3).should eql(1)

- 3.ceildiv(3).should eql(1)

- 4.ceildiv(3).should eql(2)

- 4.ceildiv(-3).should eql(-1)

- -4.ceildiv(3).should eql(-1)

- -4.ceildiv(-3).should eql(2)

- 3.ceildiv(1.2).should eql(3)

- 3.ceildiv(6/5r).should eql(3)

- (10**100-11).ceildiv(10**99-1).should eql(10)

- (10**100-9).ceildiv(10**99-1).should eql(11)

- end

- ruby_version_is ""..."3.2" do

- it "is unified into Integer" do

- suppress_warning do

- Fixnum.should equal(Integer)

- end

- end

-

- it "is deprecated" do

- -> { Fixnum }.should complain(/constant ::Fixnum is deprecated/)

- end

- end

-

- ruby_version_is "3.2" do

- it "is no longer defined" do

- Object.should_not.const_defined?(:Fixnum)

- end

- ruby_version_is ""..."3.2" do

- it "is unified into Integer" do

- suppress_warning do

- Bignum.should equal(Integer)

- end

- end

-

- it "is deprecated" do

- -> { Bignum }.should complain(/constant ::Bignum is deprecated/)

- end

- end

-

- ruby_version_is "3.2" do

- it "is no longer defined" do

- Object.should_not.const_defined?(:Bignum)

- end

- ruby_bug "#18517", ""..."3.2" do

- it "returns 0 when m > 0 long and n == 0" do

- (0 << (2**40)).should == 0

- end

- ruby_bug "#18517", ""..."3.2" do

- it "returns 0 when m < 0 long and n == 0" do

- (0 >> -(2**40)).should == 0

- end

- ruby_version_is "3.2" do

- it "returns the path of the file associated with the IO object" do

- path = tmp("io_path.txt")

- File.open(path, "w") do |file|

- IO.new(file.fileno, path: file.path, autoclose: false).path.should == file.path

- end

- ensure

- File.unlink(path)

- ruby_version_is "3.2" do

- it "yields self's content" do

- @io.pos = 100

- @io.send(@method, nil, chomp: true) { |s| ScratchPad << s }

- ScratchPad.recorded.should == ["qui a linha cinco.\nHere is line six.\n"]

- end

- end

-

- ruby_version_is ""..."3.2" do

- it "yields self's content without trailing new line character" do

- @io.pos = 100

- @io.send(@method, nil, chomp: true) { |s| ScratchPad << s }

- ScratchPad.recorded.should == ["qui a linha cinco.\nHere is line six."]

- end

- guard_not -> { platform_is :windows and ruby_version_is ""..."3.2" } do # https://bugs.ruby-lang.org/issues/18880

- it "raises ArgumentError when length is less than 0" do

- -> { @read.sysread(-1) }.should raise_error(ArgumentError)

- end

- ruby_version_is ''...'3.2' do

- it "returns nil matching any object" do

- o = Object.new

-

- suppress_warning do

- (o =~ /Object/).should be_nil

- (o =~ 'Object').should be_nil

- (o =~ Object).should be_nil

- (o =~ Object.new).should be_nil

- (o =~ nil).should be_nil

- (o =~ true).should be_nil

- end

- end

-

- it "is deprecated" do

- -> do

- Object.new =~ /regexp/

- end.should complain(/deprecated Object#=~ is called on Object/, verbose: true)

- end

- end

-

- ruby_version_is '3.2' do

- it "is no longer defined" do

- Object.new.should_not.respond_to?(:=~)

- end

- ruby_version_is ""..."3.2" do

- it "returns true if self does not respond to #=~" do

- suppress_warning do

- (Object.new !~ :foo).should == true

- end

- end

- end

-

- ruby_version_is "3.2" do

- it "raises NoMethodError if self does not respond to #=~" do

- -> { Object.new !~ :foo }.should raise_error(NoMethodError)

- end

- it "calls #to_path to covert the argument to a String before calling #to_str" do

- ruby_version_is ""..."3.2" do

- it "raises ArgumentError if argument is a string of several characters" do

- -> {

- @method.call("%c", "abc")

- }.should raise_error(ArgumentError, /%c requires a character/)

- end

-

- it "raises ArgumentError if argument is an empty string" do

- -> {

- @method.call("%c", "")

- }.should raise_error(ArgumentError, /%c requires a character/)

- end

- ruby_version_is "3.2" do

- it "displays only the first character if argument is a string of several characters" do

- @method.call("%c", "abc").should == "a"

- end

-

- it "displays no characters if argument is an empty string" do

- @method.call("%c", "").should == ""

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = Object.new

- o.taint

- o.should_not.tainted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- obj = mock("tainted")

- obj.taint

- }.should complain(/Object#taint is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:taint)

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = mock('o')

- p = mock('p')

- p.taint

- o.should_not.tainted?

- p.should_not.tainted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- o = mock('o')

- o.tainted?

- }.should complain(/Object#tainted\? is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:tainted?)

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = Object.new.untrust

- o.should_not.untrusted?

- o.trust

- o.should_not.untrusted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- o = Object.new.untrust

- o.trust

- }.should complain(/Object#trust is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:trust)

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = Object.new.taint

- o.should_not.tainted?

- o.untaint

- o.should_not.tainted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- o = Object.new.taint

- o.untaint

- }.should complain(/Object#untaint is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:untaint)

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = Object.new

- o.untrust

- o.should_not.untrusted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- o = Object.new

- o.untrust

- }.should complain(/Object#untrust is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:untrust)

- end

- ruby_version_is ""..."3.2" do

- it "is a no-op" do

- suppress_warning do

- o = mock('o')

- o.should_not.untrusted?

- o.untrust

- o.should_not.untrusted?

- end

- end

-

- it "warns in verbose mode" do

- -> {

- o = mock('o')

- o.untrusted?

- }.should complain(/Object#untrusted\? is deprecated and will be removed in Ruby 3.2/, verbose: true)

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- Object.new.should_not.respond_to?(:untrusted?)

- end

- ruby_version_is "3.2" do

- it "does not raise error when wrapped with module" do

- -> do

- load File.expand_path('../fixtures/using.rb', __FILE__), true

- end.should_not raise_error

- end

- ruby_version_is "3.2" do

- describe "with a Data" do

- it "dumps a Data" do

- Marshal.dump(MarshalSpec::DataSpec::Measure.new(100, 'km')).should == "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"

- end

- it "dumps an extended Data" do

- obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")

- Marshal.dump(obj).should == "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"

- end

- it "ignores overridden name method" do

- obj = MarshalSpec::DataSpec::MeasureWithOverriddenName.new(100, "km")

- Marshal.dump(obj).should == "\x04\bS:5MarshalSpec::DataSpec::MeasureWithOverriddenName\a:\vamountii:\tunit\"\akm"

- end

- it "uses object links for objects repeatedly dumped" do

- d = MarshalSpec::DataSpec::Measure.new(100, 'km')

- Marshal.dump([d, d]).should == "\x04\b[\aS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm@\x06" # @\x06 is a link to the object

- end

- it "raises TypeError with an anonymous Struct" do

- -> { Marshal.dump(Data.define(:a).new(1)) }.should raise_error(TypeError, /can't dump anonymous class/)

- end

- if defined? Data # TODO: remove the condition when minimal supported version is 3.2

- module DataSpec

- Measure = Data.define(:amount, :unit)

- Empty = Data.define

-

- MeasureExtended = Class.new(Measure)

- MeasureExtended.extend(Enumerable)

-

- class MeasureWithOverriddenName < Measure

- def self.name

- "Foo"

- end

- ruby_bug "#19427", "3.1"..."3.3" do

- ruby_version_is "3.2" do

- describe "for a Data" do

- it "loads a Data" do

- obj = MarshalSpec::DataSpec::Measure.new(100, 'km')

- dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"

- Marshal.dump(obj).should == dumped

- Marshal.send(@method, dumped).should == obj

- end

- it "loads an extended Data" do

- obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")

- dumped = "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"

- Marshal.dump(obj).should == dumped

- Marshal.send(@method, dumped).should == obj

- end

- it "returns a frozen object" do

- obj = MarshalSpec::DataSpec::Measure.new(100, 'km')

- dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"

- Marshal.dump(obj).should == dumped

- Marshal.send(@method, dumped).should.frozen?

- end

- ruby_version_is "3.2" do

- it "returns beginning and ending byte-based offset of whole matched substring for 0 element" do

- m = /(.)(.)(\d+)(\d)/.match("THX1138.")

- m.byteoffset(0).should == [1, 7]

- end

- it "returns beginning and ending byte-based offset of n-th match, all the subsequent elements are capturing groups" do

- m = /(.)(.)(\d+)(\d)/.match("THX1138.")

- m.byteoffset(2).should == [2, 3]

- m.byteoffset(3).should == [3, 6]

- m.byteoffset(4).should == [6, 7]

- end

- it "accepts String as a reference to a named capture" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.byteoffset("f").should == [0, 3]

- m.byteoffset("b").should == [3, 6]

- end

- it "accepts Symbol as a reference to a named capture" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.byteoffset(:f).should == [0, 3]

- m.byteoffset(:b).should == [3, 6]

- end

- it "returns [nil, nil] if a capturing group is optional and doesn't match" do

- m = /(?<x>q..)?/.match("foobarbaz")

- m.byteoffset("x").should == [nil, nil]

- m.byteoffset(1).should == [nil, nil]

- end

- it "returns correct beginning and ending byte-based offset for multi-byte strings" do

- m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")

- m.byteoffset(1).should == [3, 6]

- m.byteoffset(3).should == [6, 9]

- end

- it "returns [nil, nil] if a capturing group is optional and doesn't match for multi-byte string" do

- m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")

- m.byteoffset(2).should == [nil, nil]

- end

- it "converts argument into integer if is not String nor Symbol" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- obj = Object.new

- def obj.to_int; 2; end

- m.byteoffset(1r).should == [0, 3]

- m.byteoffset(1.1).should == [0, 3]

- m.byteoffset(obj).should == [3, 6]

- end

- it "raises IndexError if there is no group with the provided name" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- -> {

- m.byteoffset("y")

- }.should raise_error(IndexError, "undefined group name reference: y")

- -> {

- m.byteoffset(:y)

- }.should raise_error(IndexError, "undefined group name reference: y")

- end

- it "raises IndexError if index is out of bounds" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- -> {

- m.byteoffset(-1)

- }.should raise_error(IndexError, "index -1 out of matches")

- -> {

- m.byteoffset(3)

- }.should raise_error(IndexError, "index 3 out of matches")

- end

- it "raises TypeError if can't convert argument into Integer" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- -> {

- m.byteoffset([])

- }.should raise_error(TypeError, "no implicit conversion of Array into Integer")

- end

- ruby_version_is "3.2" do

- it "returns whole hash for nil as an argument" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.deconstruct_keys(nil).should == { f: "foo", b: "bar" }

- end

- it "returns only specified keys" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.deconstruct_keys([:f]).should == { f: "foo" }

- end

- it "requires one argument" do

- m = /l/.match("l")

- -> {

- m.deconstruct_keys

- }.should raise_error(ArgumentError, "wrong number of arguments (given 0, expected 1)")

- end

- it "it raises error when argument is neither nil nor array" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- -> { m.deconstruct_keys(1) }.should raise_error(TypeError, "wrong argument type Integer (expected Array)")

- -> { m.deconstruct_keys("asd") }.should raise_error(TypeError, "wrong argument type String (expected Array)")

- -> { m.deconstruct_keys(:x) }.should raise_error(TypeError, "wrong argument type Symbol (expected Array)")

- -> { m.deconstruct_keys({}) }.should raise_error(TypeError, "wrong argument type Hash (expected Array)")

- end

- it "returns {} when passed []" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.deconstruct_keys([]).should == {}

- end

- it "does not accept non-Symbol keys" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- -> {

- m.deconstruct_keys(['year', :foo])

- }.should raise_error(TypeError, "wrong argument type String (expected Symbol)")

- end

- it "process keys till the first non-existing one" do

- m = /(?<f>foo)(?<b>bar)(?<c>baz)/.match("foobarbaz")

- m.deconstruct_keys([:f, :a, :b]).should == { f: "foo" }

- end

- it "returns {} when there are no named captured groups at all" do

- m = /foo.+/.match("foobar")

- m.deconstruct_keys(nil).should == {}

- end

- it "returns {} when passed more keys than named captured groups" do

- m = /(?<f>foo)(?<b>bar)/.match("foobar")

- m.deconstruct_keys([:f, :b, :c]).should == {}

- end

- ruby_version_is "3.2" do

- it_behaves_like :matchdata_captures, :deconstruct

- end

- ruby_version_is "3.2" do

- it "returns the class on which public was called for a private method in ancestor" do

- MethodSpecs::InheritedMethods::C.new.method(:derp).owner.should == MethodSpecs::InheritedMethods::C

- end

- ruby_version_is '3.2' do

- it "adds rest arg with name * for \"star\" argument" do

- m = MethodSpecs::Methods.new

- m.method(:one_unnamed_splat).parameters.should == [[:rest, :*]]

- end

-

- it "adds keyrest arg with ** as a name for \"double star\" argument" do

- m = MethodSpecs::Methods.new

- m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest, :**]]

- end

- ruby_version_is ''...'3.2' do

- it "adds nameless rest arg for \"star\" argument" do

- m = MethodSpecs::Methods.new

- m.method(:one_unnamed_splat).parameters.should == [[:rest]]

- end

-

- it "adds nameless keyrest arg for \"double star\" argument" do

- m = MethodSpecs::Methods.new

- m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest]]

- end

- ruby_version_is ""..."3.2" do

- it "returns false when the method is public" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_public_method).private?.should == false

- end

-

- it "returns false when the method is protected" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_protected_method).private?.should == false

- end

-

- it "returns true when the method is private" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_private_method).private?.should == true

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_private_method).should_not.respond_to?(:private?)

- end

- ruby_version_is ""..."3.2" do

- it "returns false when the method is public" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_public_method).protected?.should == false

- end

-

- it "returns true when the method is protected" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_protected_method).protected?.should == true

- end

-

- it "returns false when the method is private" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_private_method).protected?.should == false

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_protected_method).should_not.respond_to?(:protected?)

- end

- ruby_version_is ""..."3.2" do

- it "returns true when the method is public" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_public_method).public?.should == true

- end

-

- it "returns false when the method is protected" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_protected_method).public?.should == false

- end

-

- it "returns false when the method is private" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_private_method).public?.should == false

- end

- end

-

- ruby_version_is "3.2" do

- it "has been removed" do

- obj = MethodSpecs::Methods.new

- obj.method(:my_public_method).should_not.respond_to?(:public?)

- end

- ruby_version_is ""..."3.2" do

- it "returns a String containing the Module the method is referenced from" do

- @string.should =~ /MethodSpecs::MySub/

- end

- end

-

- ruby_version_is "3.2" do

- it "returns a String containing the Module the method is referenced from" do

- @string.should =~ /MethodSpecs::MyMod/

- end

- ruby_version_is "3.2" do

- it "warns once in verbose mode if the constant was defined in a parent scope" do

- ScratchPad.record -> {

- ModuleSpecs::DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent

- }

- module ModuleSpecs

- module Autoload

- autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")

- self.autoload?(:DeclaredInCurrentDefinedInParent).should == fixture(__FILE__, "autoload_callback.rb")

- const_defined?(:DeclaredInCurrentDefinedInParent).should == true

-

- -> {

- DeclaredInCurrentDefinedInParent

- }.should complain(

- /Expected .*autoload_callback.rb to define ModuleSpecs::Autoload::DeclaredInCurrentDefinedInParent but it didn't/,

- verbose: true,

- )

-

- -> {

- DeclaredInCurrentDefinedInParent

- }.should_not complain(/.*/, verbose: true)

- self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil

- const_defined?(:DeclaredInCurrentDefinedInParent).should == false

- ModuleSpecs.const_defined?(:DeclaredInCurrentDefinedInParent).should == true

- end

- ruby_version_is "3.2" do

- it "is a private instance method" do

- Module.should have_private_instance_method(:const_added)

- it "returns nil in the default implementation" do

- Module.new do

- const_added(:TEST).should == nil

- it "is called when a new constant is assigned on self" do

- ScratchPad.record []

-

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- TEST = 1

- RUBY

- ScratchPad.recorded.should == [:TEST]

- end

- it "is called when a new constant is assigned on self through const_set" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- mod.const_set(:TEST, 1)

- ScratchPad.recorded.should == [:TEST]

- end

- it "is called when a new module is defined under self" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- module SubModule

- end

- module SubModule

- end

- RUBY

- ScratchPad.recorded.should == [:SubModule]

- it "is called when a new module is defined under a named module (assigned to a constant)" do

- ScratchPad.record []

- ModuleSpecs::ConstAddedSpecs::NamedModule = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- module self::A

- def self.const_added(name)

- ScratchPad << name

- end

- module self::B

- end

- end

-

- ScratchPad.recorded.should == [:A, :B]

- it "is called when a new class is defined under self" do

- ScratchPad.record []

-

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- class SubClass

- end

- class SubClass

- end

- RUBY

- ScratchPad.recorded.should == [:SubClass]

- end

- it "is called when a new class is defined under a named module (assigned to a constant)" do

- ScratchPad.record []

- ModuleSpecs::ConstAddedSpecs::NamedModuleB = Module.new do

- class self::A

- def self.const_added(name)

- ScratchPad << name

- end

-

- class self::B

- end

-

- ScratchPad.recorded.should == [:A, :B]

- it "is called when an autoload is defined" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << name

- end

- end

- mod.autoload :Autoload, "foo"

- ScratchPad.recorded.should == [:Autoload]

- it "is called with a precise caller location with the line of definition" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- location = caller_locations(1, 1)[0]

- ScratchPad << location.lineno

- end

- line = __LINE__

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- TEST = 1

- module SubModule

- end

- class SubClass

- end

- RUBY

- mod.const_set(:CONST_SET, 1)

- ScratchPad.recorded.should == [line + 2, line + 4, line + 7, line + 11]

- it "is called when the constant is already assigned a value" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- ScratchPad.record const_get(name)

- end

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- TEST = 123

- RUBY

- ScratchPad.recorded.should == 123

- it "records re-definition of existing constants" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(name)

- ScratchPad << const_get(name)

- end

- -> {

- mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)

- TEST = 123

- TEST = 456

- RUBY

- }.should complain(/warning: already initialized constant .+::TEST/)

- ScratchPad.recorded.should == [123, 456]

- end

- it "for a class defined with the `class` keyword, const_added runs before inherited" do

- ScratchPad.record []

- mod = Module.new do

- def self.const_added(_)

- ScratchPad << :const_added

- end

- end

- parent = Class.new do

- def self.inherited(_)

- ScratchPad << :inherited

- end

- class mod::C < parent; end

- ScratchPad.recorded.should == [:const_added, :inherited]

- end

- it "the superclass of a class assigned to a constant is set before const_added is called" do

- ScratchPad.record []

- parent = Class.new do

- def self.const_added(name)

- ScratchPad << name

- ScratchPad << const_get(name).superclass

- end

- class parent::C < parent; end

- ScratchPad.recorded.should == [:C, parent]

- end

- ruby_version_is ""..."3.2" do

- it "raises ArgumentError when the argument is a refinement" do

- refinement = nil

- Module.new do

- refine String do

- refinement = self

- end

-

- -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")

- end

-

- ruby_version_is "3.2" do

- it "raises a TypeError when the argument is a refinement" do

- refinement = nil

- Module.new do

- refine String do

- refinement = self

- end

- end

-

- -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(TypeError, "Cannot include refinement")

- end

-

- ruby_version_is ""..."3.2" do

- @child_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/

- @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/

- end

- ruby_version_is "3.2" do

- it "is set in #const_added callback when a module defined in the top-level scope" do

- ruby_exe(<<~RUBY, args: "2>&1").chomp.should == "TEST1\nTEST2"

- class Module

- def const_added(name)

- puts const_get(name).name

- end

- # module with name

- module TEST1

- end

- # anonymous module

- TEST2 = Module.new

- RUBY

- end

- it "is set in #const_added callback for a nested module when an outer module defined in the top-level scope" do

- ScratchPad.record []

- ModuleSpecs::NameSpecs::NamedModule = Module.new do

- module self::A

- def self.const_added(name)

- ScratchPad << const_get(name).name

- end

-

- module self::B

- end

-

- ScratchPad.recorded.should.one?(/#<Module.+>::A$/)

- ScratchPad.recorded.should.one?(/#<Module.+>::A::B$/)

- ruby_version_is ""..."3.2" do

- it "raises ArgumentError when the argument is a refinement" do

- refinement = nil

- Module.new do

- refine String do

- refinement = self

- end

-

- -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")

- end

-

- ruby_version_is "3.2" do

- it "raises a TypeError when the argument is a refinement" do

- refinement = nil

- Module.new do

- refine String do

- refinement = self

- end

- end

-

- -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(TypeError, "Cannot prepend refinement")

- end

- ruby_version_is ""..."3.2" do

- it "looks in the included modules for builtin methods" do

- result = ruby_exe(<<-RUBY)

- a = Module.new do

- def /(other) quo(other) end

- end

-

- refinement = Module.new do

- refine Integer do

- include a

- end

- end

-

- result = nil

- Module.new do

- using refinement

- result = 1 / 2

- end

-

- print result.class

- RUBY

-

- result.should == 'Rational'

- end

- end

-

- ruby_version_is "3.2" do

- it "returns refinements defined in a module" do

- ScratchPad.record []

-

- m = Module.new do

- refine String do

- ScratchPad << self

- end

-

- refine Array do

- ScratchPad << self

- end

- m.refinements.sort_by(&:object_id).should == ScratchPad.recorded.sort_by(&:object_id)

- it "does not return refinements defined in the included module" do

- ScratchPad.record []

- m1 = Module.new do

- refine Integer do

- nil

- end

- m2 = Module.new do

- include m1

- refine String do

- ScratchPad << self

- end

-

- m2.refinements.should == ScratchPad.recorded

- it "returns an empty array if no refinements defined in a module" do

- Module.new.refinements.should == []

- end

- ruby_version_is "3.2" do

- it "makes a copy and unmark the Hash when calling a method taking (*args)" do

- obj = Object.new

- obj.singleton_class.class_exec do

- def splat(*args)

- args.last

- end

-

- def splat1(arg, *args)

- args.last

- end

- def proc_call(*args)

- -> *a { a.last }.call(*args)

- end

- h = { a: 1 }

- args = mark(**h)

- marked = args.last

- Hash.ruby2_keywords_hash?(marked).should == true

-

- after_usage = obj.splat(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should_not.equal?(marked)

- Hash.ruby2_keywords_hash?(after_usage).should == false

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(1, **h)

- marked = args.last

- after_usage = obj.splat1(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should_not.equal?(marked)

- Hash.ruby2_keywords_hash?(after_usage).should == false

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(**h)

- marked = args.last

- after_usage = obj.proc_call(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should_not.equal?(marked)

- Hash.ruby2_keywords_hash?(after_usage).should == false

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(**h)

- marked = args.last

- after_usage = obj.send(:splat, *args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should_not.equal?(marked)

- Hash.ruby2_keywords_hash?(after_usage).should == false

- Hash.ruby2_keywords_hash?(marked).should == true

- end

- ruby_version_is ""..."3.2" do

- # https://bugs.ruby-lang.org/issues/18625

- it "does NOT copy the Hash when calling a method taking (*args)" do

- obj = Object.new

- obj.singleton_class.class_exec do

- def splat(*args)

- args.last

- end

- def splat1(arg, *args)

- args.last

- end

- def proc_call(*args)

- -> *a { a.last }.call(*args)

- end

- end

- h = { a: 1 }

- args = mark(**h)

- marked = args.last

- Hash.ruby2_keywords_hash?(marked).should == true

-

- after_usage = obj.splat(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(1, **h)

- marked = args.last

- after_usage = obj.splat1(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(**h)

- marked = args.last

- after_usage = obj.proc_call(*args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625

- Hash.ruby2_keywords_hash?(marked).should == true

-

- args = mark(**h)

- marked = args.last

- after_usage = obj.send(:splat, *args)

- after_usage.should == h

- after_usage.should_not.equal?(h)

- send_copies = RUBY_ENGINE == "ruby" # inconsistent with Proc#call above for CRuby

- after_usage.equal?(marked).should == !send_copies

- Hash.ruby2_keywords_hash?(after_usage).should == !send_copies

- Hash.ruby2_keywords_hash?(marked).should == true

- end

- ruby_version_is "3.2" do

- it "returns methods undefined in the class" do

- methods = ModuleSpecs::UndefinedInstanceMethods::Parent.undefined_instance_methods

- methods.should == [:undefed_method]

- end

- it "returns inherited methods undefined in the class" do

- methods = ModuleSpecs::UndefinedInstanceMethods::Child.undefined_instance_methods

- methods.should include(:parent_method, :another_parent_method)

- end

- it "returns methods from an included module that are undefined in the class" do

- methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods

- methods.should include(:super_included_method)

- end

- it "does not returns ancestors undefined methods" do

- methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods

- methods.should_not include(:parent_method, :another_parent_method)

- end

- ruby_version_is "3.2" do

- it "returns list of all refinements imported in the current scope" do

- refinement_int = nil

- refinement_str = nil

- ScratchPad.record []

-

- m1 = Module.new do

- refine Integer do

- refinement_int = self

- end

- m2 = Module.new do

- refine String do

- refinement_str = self

- end

- Module.new do

- using m1

- using m2

- Module.used_refinements.each { |r| ScratchPad << r }

- end

-

- ScratchPad.recorded.sort_by(&:object_id).should == [refinement_int, refinement_str].sort_by(&:object_id)

- it "returns empty array if does not have any refinements imported" do

- used_refinements = nil

- Module.new do

- used_refinements = Module.used_refinements

- end

- used_refinements.should == []

- it "ignores refinements imported in a module that is included into the current one" do

- used_refinements = nil

- m1 = Module.new do

- refine Integer do

- nil

- end

- end

- m2 = Module.new do

- using m1

- Module.new do

- include m2

- used_refinements = Module.used_refinements

- end

- used_refinements.should == []

- it "returns refinements even not defined directly in a module refinements are imported from" do

- used_refinements = nil

- ScratchPad.record []

- m1 = Module.new do

- refine Integer do

- ScratchPad << self

- end

- end

- m2 = Module.new do

- include m1

- Module.new do

- using m2

- used_refinements = Module.used_refinements

- end

- used_refinements.should == ScratchPad.recorded

- ruby_version_is "3.2" do

- it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do

- proc {|x| }.parameters(lambda: true).first.first.should == :req

- proc {|y,*x| }.parameters(lambda: true).first.first.should == :req

- end

- it "regards named parameters in procs as required if lambda keyword used" do

- proc {|x| }.parameters(lambda: true).first.first.should == :req

- end

- it "regards named parameters in lambda as optional if lambda: false keyword used" do

- -> x { }.parameters(lambda: false).first.first.should == :opt

- end

- it "regards named parameters in procs and lambdas as required if lambda keyword is truthy" do

- proc {|x| }.parameters(lambda: 123).first.first.should == :req

- -> x { }.parameters(lambda: 123).first.first.should == :req

- end

- it "ignores the lambda keyword if it is nil" do

- proc {|x|}.parameters(lambda: nil).first.first.should == :opt

- -> x { }.parameters(lambda: nil).first.first.should == :req

- end

- ruby_version_is '3.2' do

- it "adds rest arg with name * for \"star\" argument" do

- -> * {}.parameters.should == [[:rest, :*]]

- end

-

- it "adds keyrest arg with ** as a name for \"double star\" argument" do

- -> ** {}.parameters.should == [[:keyrest, :**]]

- end

- ruby_version_is ''...'3.2' do

- it "adds nameless rest arg for \"star\" argument" do

- -> * {}.parameters.should == [[:rest]]

- end

-

- it "adds nameless keyrest arg for \"double star\" argument" do

- -> ** {}.parameters.should == [[:keyrest]]

- end

- ruby_version_is "3.2" do

- it "returns an instance of subclass" do

- cl = Class.new(Proc)

- cl.new{}.send(@method).class.should == cl

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.deq(timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.pop(timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.shift(timeout: v) }

- end

- ruby_version_is ''...'3.2' do

- it "returns a random number generator" do

- suppress_warning do

- Random::DEFAULT.should respond_to(:rand)

- end

- end

-

- it "changes seed on reboot" do

- seed1 = ruby_exe('p Random::DEFAULT.seed', options: '--disable-gems')

- seed2 = ruby_exe('p Random::DEFAULT.seed', options: '--disable-gems')

- seed1.should != seed2

- end

-

- it "refers to the Random class" do

- suppress_warning do

- Random::DEFAULT.should.equal?(Random)

- end

- end

-

- it "is deprecated" do

- -> {

- Random::DEFAULT.should.equal?(Random)

- }.should complain(/constant Random::DEFAULT is deprecated/)

- end

- end

-

- ruby_version_is '3.2' do

- it "is no longer defined" do

- Random.should_not.const_defined?(:DEFAULT)

- end

- ruby_bug "#19533", "3.2"..."3.3" do

- ruby_bug '#18994', '2.7'...'3.2' do

- it "returns the specified number if elements for single element inclusive range" do

- (1..1).last(1).should == [1]

- end

- ruby_version_is ""..."3.2" do

- it 'returns Float::INFINITY for all beginless ranges' do

- (..1).size.should == Float::INFINITY

- (...0.5).size.should == Float::INFINITY

- (..nil).size.should == Float::INFINITY

- (...'o').size.should == Float::INFINITY

- end

- end

-

- ruby_version_is "3.2"..."3.4" do

- ruby_version_is "3.2" do

- it "is not defined" do

- Refinement.should_not have_private_instance_method(:append_features)

- end

- it "is not called by Module#include" do

- c = Class.new

- Module.new do

- refine c do

- called = false

- define_method(:append_features){called = true}

- proc{c.include(self)}.should raise_error(TypeError)

- called.should == false

- end

- ruby_version_is "3.2" do

- it "is not defined" do

- Refinement.should_not have_private_instance_method(:extend_object)

- end

- it "is not called by Object#extend" do

- c = Class.new

- Module.new do

- refine c do

- called = false

- define_method(:extend_object) { called = true }

- -> {

- c.extend(self)

- }.should raise_error(TypeError)

- called.should == false

- end

- ruby_version_is ""..."3.2" do

- it "warns about deprecation" do

- Module.new do

- refine String do

- -> {

- include Module.new

- }.should complain(/warning: Refinement#include is deprecated and will be removed in Ruby 3.2/)

- end

- end

- end

- end

-

- ruby_version_is "3.2" do

- it "raises a TypeError" do

- Module.new do

- refine String do

- -> {

- include Module.new

- }.should raise_error(TypeError, "Refinement#include has been removed")

- end

- ruby_version_is "3.2" do

- it "is not defined" do

- Refinement.should_not have_private_instance_method(:prepend_features)

- end

- it "is not called by Module#prepend" do

- c = Class.new

- Module.new do

- refine c do

- called = false

- define_method(:prepend_features){called = true}

- proc{c.prepend(self)}.should raise_error(TypeError)

- called.should == false

- end

- ruby_version_is ""..."3.2" do

- it "warns about deprecation" do

- Module.new do

- refine String do

- -> {

- prepend Module.new

- }.should complain(/warning: Refinement#prepend is deprecated and will be removed in Ruby 3.2/)

- end

- end

- end

- end

-

- ruby_version_is "3.2" do

- it "raises a TypeError" do

- Module.new do

- refine String do

- -> {

- prepend Module.new

- }.should raise_error(TypeError, "Refinement#prepend has been removed")

- end

- ruby_version_is "3.2"..."3.3" do

-ruby_version_is "3.2" do

- describe "Regexp.linear_time?" do

- it "returns true if matching can be done in linear time" do

- Regexp.linear_time?(/a/).should == true

- Regexp.linear_time?('a').should == true

- end

- it "return false if matching can't be done in linear time" do

- Regexp.linear_time?(/(a)\1/).should == false

- Regexp.linear_time?("(a)\\1").should == false

- end

- it "accepts flags for string argument" do

- Regexp.linear_time?('a', Regexp::IGNORECASE).should == true

- end

- it "warns about flags being ignored for regexp arguments" do

- -> {

- Regexp.linear_time?(/a/, Regexp::IGNORECASE)

- }.should complain(/warning: flags ignored/)

- end

- ruby_version_is ""..."3.2" do

- it "does not try to convert the second argument to Integer with #to_int method call" do

- ScratchPad.clear

- obj = Object.new

- def obj.to_int() ScratchPad.record(:called) end

- ScratchPad.recorded.should == nil

- end

- end

-

- ruby_version_is "3.2" do

- it "does not try to convert the second argument to Integer with #to_int method call" do

- ScratchPad.clear

- obj = Object.new

- def obj.to_int() ScratchPad.record(:called) end

-

- -> {

- Regexp.send(@method, "Hi", obj)

- }.should complain(/expected true or false as ignorecase/, {verbose: true})

-

- ScratchPad.recorded.should == nil

- end

- ruby_version_is ""..."3.2" do

- it "treats any non-Integer, non-nil, non-false second argument as IGNORECASE" do

- (r.options & Regexp::IGNORECASE).should_not == 0

- (r.options & Regexp::MULTILINE).should == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should == 0

- end

- end

- end

-

- ruby_version_is "3.2" do

- it "warns any non-Integer, non-nil, non-false second argument" do

- r = nil

- -> {

- r = Regexp.send(@method, 'Hi', Object.new)

- }.should complain(/expected true or false as ignorecase/, {verbose: true})

- (r.options & Regexp::IGNORECASE).should_not == 0

- (r.options & Regexp::MULTILINE).should == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should == 0

- end

- end

-

- it "accepts a String of supported flags as the second argument" do

- r = Regexp.send(@method, 'Hi', 'i')

- (r.options & Regexp::IGNORECASE).should_not == 0

- (r.options & Regexp::MULTILINE).should == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should == 0

- end

-

- r = Regexp.send(@method, 'Hi', 'imx')

- (r.options & Regexp::IGNORECASE).should_not == 0

- (r.options & Regexp::MULTILINE).should_not == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should_not == 0

- end

-

- r = Regexp.send(@method, 'Hi', 'mimi')

- (r.options & Regexp::IGNORECASE).should_not == 0

- (r.options & Regexp::MULTILINE).should_not == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should == 0

- end

-

- r = Regexp.send(@method, 'Hi', '')

- (r.options & Regexp::IGNORECASE).should == 0

- (r.options & Regexp::MULTILINE).should == 0

- not_supported_on :opal do

- (r.options & Regexp::EXTENDED).should == 0

- end

- end

-

- it "raises an Argument error if the second argument contains unsupported chars" do

- -> { Regexp.send(@method, 'Hi', 'e') }.should raise_error(ArgumentError, "unknown regexp option: e")

- -> { Regexp.send(@method, 'Hi', 'n') }.should raise_error(ArgumentError, "unknown regexp option: n")

- -> { Regexp.send(@method, 'Hi', 's') }.should raise_error(ArgumentError, "unknown regexp option: s")

- -> { Regexp.send(@method, 'Hi', 'u') }.should raise_error(ArgumentError, "unknown regexp option: u")

- -> { Regexp.send(@method, 'Hi', 'j') }.should raise_error(ArgumentError, "unknown regexp option: j")

- -> { Regexp.send(@method, 'Hi', 'mjx') }.should raise_error(ArgumentError, /unknown regexp option: mjx\b/)

- ruby_version_is ""..."3.2" do

- it "ignores the third argument if it is 'e' or 'euc' (case-insensitive)" do

- -> {

- Regexp.send(@method, 'Hi', nil, 'e').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'euc').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'E').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'EUC').encoding.should == Encoding::US_ASCII

- }.should complain(/encoding option is ignored/)

- it "ignores the third argument if it is 's' or 'sjis' (case-insensitive)" do

- -> {

- Regexp.send(@method, 'Hi', nil, 's').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'sjis').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'S').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'SJIS').encoding.should == Encoding::US_ASCII

- }.should complain(/encoding option is ignored/)

- it "ignores the third argument if it is 'u' or 'utf8' (case-insensitive)" do

- -> {

- Regexp.send(@method, 'Hi', nil, 'u').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'utf8').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'U').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'UTF8').encoding.should == Encoding::US_ASCII

- }.should complain(/encoding option is ignored/)

- it "uses US_ASCII encoding if third argument is 'n' or 'none' (case insensitive) and only ascii characters" do

- Regexp.send(@method, 'Hi', nil, 'n').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'none').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'N').encoding.should == Encoding::US_ASCII

- Regexp.send(@method, 'Hi', nil, 'NONE').encoding.should == Encoding::US_ASCII

- it "uses ASCII_8BIT encoding if third argument is 'n' or 'none' (case insensitive) and non-ascii characters" do

- a = "(?:[\x8E\xA1-\xFE])"

- str = "\A(?:#{a}|x*)\z"

-

- Regexp.send(@method, str, nil, 'N').encoding.should == Encoding::BINARY

- Regexp.send(@method, str, nil, 'n').encoding.should == Encoding::BINARY

- Regexp.send(@method, str, nil, 'none').encoding.should == Encoding::BINARY

- Regexp.send(@method, str, nil, 'NONE').encoding.should == Encoding::BINARY

- end

-

- ruby_version_is ''...'3.2' do

- it "sets the encoding to source String's encoding if the Regexp literal has the 'n' option and the source String is not ASCII only" do

- Regexp.send(@method, Regexp.new("\\xff", nil, 'n')).encoding.should == Encoding::BINARY

- end

- end

-ruby_version_is "3.2" do

- describe "Regexp.timeout" do

- after :each do

- Regexp.timeout = nil

- end

- it "returns global timeout" do

- Regexp.timeout = 3

- Regexp.timeout.should == 3

- end

- it "raises Regexp::TimeoutError after global timeout elapsed" do

- Regexp.timeout = 0.001

- Regexp.timeout.should == 0.001

- -> {

- # A typical ReDoS case

- /^(a*)*$/ =~ "a" * 1000000 + "x"

- }.should raise_error(Regexp::TimeoutError, "regexp match timeout")

- end

- it "raises Regexp::TimeoutError after timeout keyword value elapsed" do

- Regexp.timeout = 3 # This should be ignored

- Regexp.timeout.should == 3

- re = Regexp.new("^a*b?a*$", timeout: 0.001)

- -> {

- re =~ "a" * 1000000 + "x"

- }.should raise_error(Regexp::TimeoutError, "regexp match timeout")

- end

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

-require 'set'

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.send(:<<, 1, timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.deq(timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.enq(1, timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.pop(timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.push(1, timeout: v) }

- end

- ruby_version_is "3.2" do

- it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.shift(timeout: v) }

- end

- ruby_version_is "3.2" do

- it "calls #to_str to convert the first argument" do

- char = mock("string index char")

- char.should_receive(:to_str).and_return("b")

- "abc".byteindex(char).should == 1

- end

-

- it "calls #to_int to convert the second argument" do

- offset = mock("string index offset")

- offset.should_receive(:to_int).and_return(1)

- "abc".byteindex("c", offset).should == 2

- end

- it "does not raise IndexError when byte offset is correct or on string boundary" do

- "わ".byteindex("").should == 0

- "わ".byteindex("", 0).should == 0

- "わ".byteindex("", 3).should == 3

- end

- it_behaves_like :byte_index_common, :byteindex

- ruby_version_is "3.2" do

- it "behaves the same as String#byteindex(char) for one-character strings" do

- "blablabla hello cruel world...!".split("").uniq.each do |str|

- chr = str[0]

- str.byteindex(str).should == str.byteindex(chr)

- 0.upto(str.size + 1) do |start|

- str.byteindex(str, start).should == str.byteindex(chr, start)

- end

- (-str.size - 1).upto(-1) do |start|

- str.byteindex(str, start).should == str.byteindex(chr, start)

- end

- it "returns the byteindex of the first occurrence of the given substring" do

- "blablabla".byteindex("").should == 0

- "blablabla".byteindex("b").should == 0

- "blablabla".byteindex("bla").should == 0

- "blablabla".byteindex("blabla").should == 0

- "blablabla".byteindex("blablabla").should == 0

-

- "blablabla".byteindex("l").should == 1

- "blablabla".byteindex("la").should == 1

- "blablabla".byteindex("labla").should == 1

- "blablabla".byteindex("lablabla").should == 1

-

- "blablabla".byteindex("a").should == 2

- "blablabla".byteindex("abla").should == 2

- "blablabla".byteindex("ablabla").should == 2

- end

- it "treats the offset as a byteindex" do

- "aaaaa".byteindex("a", 0).should == 0

- "aaaaa".byteindex("a", 2).should == 2

- "aaaaa".byteindex("a", 4).should == 4

- end

- it "ignores string subclasses" do

- "blablabla".byteindex(StringSpecs::MyString.new("bla")).should == 0

- StringSpecs::MyString.new("blablabla").byteindex("bla").should == 0

- StringSpecs::MyString.new("blablabla").byteindex(StringSpecs::MyString.new("bla")).should == 0

- end

- it "starts the search at the given offset" do

- "blablabla".byteindex("bl", 0).should == 0

- "blablabla".byteindex("bl", 1).should == 3

- "blablabla".byteindex("bl", 2).should == 3

- "blablabla".byteindex("bl", 3).should == 3

-

- "blablabla".byteindex("bla", 0).should == 0

- "blablabla".byteindex("bla", 1).should == 3

- "blablabla".byteindex("bla", 2).should == 3

- "blablabla".byteindex("bla", 3).should == 3

-

- "blablabla".byteindex("blab", 0).should == 0

- "blablabla".byteindex("blab", 1).should == 3

- "blablabla".byteindex("blab", 2).should == 3

- "blablabla".byteindex("blab", 3).should == 3

-

- "blablabla".byteindex("la", 1).should == 1

- "blablabla".byteindex("la", 2).should == 4

- "blablabla".byteindex("la", 3).should == 4

- "blablabla".byteindex("la", 4).should == 4

-

- "blablabla".byteindex("lab", 1).should == 1

- "blablabla".byteindex("lab", 2).should == 4

- "blablabla".byteindex("lab", 3).should == 4

- "blablabla".byteindex("lab", 4).should == 4

-

- "blablabla".byteindex("ab", 2).should == 2

- "blablabla".byteindex("ab", 3).should == 5

- "blablabla".byteindex("ab", 4).should == 5

- "blablabla".byteindex("ab", 5).should == 5

-

- "blablabla".byteindex("", 0).should == 0

- "blablabla".byteindex("", 1).should == 1

- "blablabla".byteindex("", 2).should == 2

- "blablabla".byteindex("", 7).should == 7

- "blablabla".byteindex("", 8).should == 8

- "blablabla".byteindex("", 9).should == 9

- end

- it "starts the search at offset + self.length if offset is negative" do

- str = "blablabla"

- ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|

- (-str.length .. -1).each do |offset|

- str.byteindex(needle, offset).should ==

- str.byteindex(needle, offset + str.length)

- end

- it "returns nil if the substring isn't found" do

- "blablabla".byteindex("B").should == nil

- "blablabla".byteindex("z").should == nil

- "blablabla".byteindex("BLA").should == nil

- "blablabla".byteindex("blablablabla").should == nil

- "blablabla".byteindex("", 10).should == nil

- "hello".byteindex("he", 1).should == nil

- "hello".byteindex("he", 2).should == nil

- "I’ve got a multibyte character.\n".byteindex("\n\n").should == nil

- end

- it "returns the character byteindex of a multibyte character" do

- "ありがとう".byteindex("が").should == 6

- end

- it "returns the character byteindex after offset" do

- "われわれ".byteindex("わ", 3).should == 6

- "ありがとうありがとう".byteindex("が", 9).should == 21

- end

- it "returns the character byteindex after a partial first match" do

- "</</h".byteindex("</h").should == 2

- end

- it "raises an Encoding::CompatibilityError if the encodings are incompatible" do

- char = "れ".encode Encoding::EUC_JP

- -> do

- "あれ".byteindex(char)

- end.should raise_error(Encoding::CompatibilityError)

- end

- it "handles a substring in a superset encoding" do

- 'abc'.dup.force_encoding(Encoding::US_ASCII).byteindex('é').should == nil

- end

- it "handles a substring in a subset encoding" do

- 'été'.byteindex('t'.dup.force_encoding(Encoding::US_ASCII)).should == 2

- end

- ruby_version_is "3.2" do

- it "behaves the same as String#byteindex(string) for escaped string regexps" do

- ["blablabla", "hello cruel world...!"].each do |str|

- ["", "b", "bla", "lab", "o c", "d."].each do |needle|

- regexp = Regexp.new(Regexp.escape(needle))

- str.byteindex(regexp).should == str.byteindex(needle)

-

- 0.upto(str.size + 1) do |start|

- str.byteindex(regexp, start).should == str.byteindex(needle, start)

- end

-

- (-str.size - 1).upto(-1) do |start|

- str.byteindex(regexp, start).should == str.byteindex(needle, start)

- end

- it "returns the byteindex of the first match of regexp" do

- "blablabla".byteindex(/bla/).should == 0

- "blablabla".byteindex(/BLA/i).should == 0

- "blablabla".byteindex(/.{0}/).should == 0

- "blablabla".byteindex(/.{6}/).should == 0

- "blablabla".byteindex(/.{9}/).should == 0

- "blablabla".byteindex(/.*/).should == 0

- "blablabla".byteindex(/.+/).should == 0

- "blablabla".byteindex(/lab|b/).should == 0

- not_supported_on :opal do

- "blablabla".byteindex(/\A/).should == 0

- "blablabla".byteindex(/\Z/).should == 9

- "blablabla".byteindex(/\z/).should == 9

- "blablabla\n".byteindex(/\Z/).should == 9

- "blablabla\n".byteindex(/\z/).should == 10

- end

- "blablabla".byteindex(/^/).should == 0

- "\nblablabla".byteindex(/^/).should == 0

- "b\nablabla".byteindex(/$/).should == 1

- "bl\nablabla".byteindex(/$/).should == 2

- "blablabla".byteindex(/.l./).should == 0

- end

- it "starts the search at the given offset" do

- "blablabla".byteindex(/.{0}/, 5).should == 5

- "blablabla".byteindex(/.{1}/, 5).should == 5

- "blablabla".byteindex(/.{2}/, 5).should == 5

- "blablabla".byteindex(/.{3}/, 5).should == 5

- "blablabla".byteindex(/.{4}/, 5).should == 5

-

- "blablabla".byteindex(/.{0}/, 3).should == 3

- "blablabla".byteindex(/.{1}/, 3).should == 3

- "blablabla".byteindex(/.{2}/, 3).should == 3

- "blablabla".byteindex(/.{5}/, 3).should == 3

- "blablabla".byteindex(/.{6}/, 3).should == 3

-

- "blablabla".byteindex(/.l./, 0).should == 0

- "blablabla".byteindex(/.l./, 1).should == 3

- "blablabla".byteindex(/.l./, 2).should == 3

- "blablabla".byteindex(/.l./, 3).should == 3

-

- "xblaxbla".byteindex(/x./, 0).should == 0

- "xblaxbla".byteindex(/x./, 1).should == 4

- "xblaxbla".byteindex(/x./, 2).should == 4

-

- not_supported_on :opal do

- "blablabla\n".byteindex(/\Z/, 9).should == 9

- end

- it "starts the search at offset + self.length if offset is negative" do

- str = "blablabla"

- ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|

- (-str.length .. -1).each do |offset|

- str.byteindex(needle, offset).should ==

- str.byteindex(needle, offset + str.length)

- end

- it "returns nil if the substring isn't found" do

- "blablabla".byteindex(/BLA/).should == nil

- "blablabla".byteindex(/.{10}/).should == nil

- "blaxbla".byteindex(/.x/, 3).should == nil

- "blaxbla".byteindex(/..x/, 2).should == nil

- end

- it "returns nil if the Regexp matches the empty string and the offset is out of range" do

- "ruby".byteindex(//, 12).should be_nil

- end

- it "supports \\G which matches at the given start offset" do

- "helloYOU.".byteindex(/\GYOU/, 5).should == 5

- "helloYOU.".byteindex(/\GYOU/).should == nil

- re = /\G.+YOU/

- # The # marks where \G will match.

- [

- ["#hi!YOUall.", 0],

- ["h#i!YOUall.", 1],

- ["hi#!YOUall.", 2],

- ["hi!#YOUall.", nil]

- ].each do |spec|

- start = spec[0].byteindex("#")

- str = spec[0].delete("#")

- str.byteindex(re, start).should == spec[1]

- end

- it "converts start_offset to an integer via to_int" do

- obj = mock('1')

- obj.should_receive(:to_int).and_return(1)

- "RWOARW".byteindex(/R./, obj).should == 4

- end

- it "returns the character byteindex of a multibyte character" do

- "ありがとう".byteindex(/が/).should == 6

- end

- it "returns the character byteindex after offset" do

- "われわれ".byteindex(/わ/, 3).should == 6

- end

- it "treats the offset as a byteindex" do

- "われわわれ".byteindex(/わ/, 6).should == 6

- end

- ruby_version_is "3.2" do

- it "tries to convert obj to a string via to_str" do

- obj = mock('lo')

- def obj.to_str() "lo" end

- "hello".byterindex(obj).should == "hello".byterindex("lo")

-

- obj = mock('o')

- def obj.respond_to?(arg, *) true end

- def obj.method_missing(*args) "o" end

- "hello".byterindex(obj).should == "hello".byterindex("o")

- end

-

- it "calls #to_int to convert the second argument" do

- offset = mock("string index offset")

- offset.should_receive(:to_int).and_return(3)

- "abc".byterindex("c", offset).should == 2

- end

- it "does not raise IndexError when byte offset is correct or on string boundary" do

- "わ".byterindex("", 0).should == 0

- "わ".byterindex("", 3).should == 3

- "わ".byterindex("").should == 3

- end

- it_behaves_like :byte_index_common, :byterindex

- ruby_version_is "3.2" do

- it "behaves the same as String#byterindex(char) for one-character strings" do

- "blablabla hello cruel world...!".split("").uniq.each do |str|

- chr = str[0]

- str.byterindex(str).should == str.byterindex(chr)

- 0.upto(str.size + 1) do |start|

- str.byterindex(str, start).should == str.byterindex(chr, start)

- end

- (-str.size - 1).upto(-1) do |start|

- str.byterindex(str, start).should == str.byterindex(chr, start)

- end

- it "behaves the same as String#byterindex(?char) for one-character strings" do

- "blablabla hello cruel world...!".split("").uniq.each do |str|

- chr = str[0] =~ / / ? str[0] : eval("?#{str[0]}")

- str.byterindex(str).should == str.byterindex(chr)

- 0.upto(str.size + 1) do |start|

- str.byterindex(str, start).should == str.byterindex(chr, start)

- end

- (-str.size - 1).upto(-1) do |start|

- str.byterindex(str, start).should == str.byterindex(chr, start)

- end

- it "returns the index of the last occurrence of the given substring" do

- "blablabla".byterindex("").should == 9

- "blablabla".byterindex("a").should == 8

- "blablabla".byterindex("la").should == 7

- "blablabla".byterindex("bla").should == 6

- "blablabla".byterindex("abla").should == 5

- "blablabla".byterindex("labla").should == 4

- "blablabla".byterindex("blabla").should == 3

- "blablabla".byterindex("ablabla").should == 2

- "blablabla".byterindex("lablabla").should == 1

- "blablabla".byterindex("blablabla").should == 0

-

- "blablabla".byterindex("l").should == 7

- "blablabla".byterindex("bl").should == 6

- "blablabla".byterindex("abl").should == 5

- "blablabla".byterindex("labl").should == 4

- "blablabla".byterindex("blabl").should == 3

- "blablabla".byterindex("ablabl").should == 2

- "blablabla".byterindex("lablabl").should == 1

- "blablabla".byterindex("blablabl").should == 0

-

- "blablabla".byterindex("b").should == 6

- "blablabla".byterindex("ab").should == 5

- "blablabla".byterindex("lab").should == 4

- "blablabla".byterindex("blab").should == 3

- "blablabla".byterindex("ablab").should == 2

- "blablabla".byterindex("lablab").should == 1

- "blablabla".byterindex("blablab").should == 0

- end

- it "ignores string subclasses" do

- "blablabla".byterindex(StringSpecs::MyString.new("bla")).should == 6

- StringSpecs::MyString.new("blablabla").byterindex("bla").should == 6

- StringSpecs::MyString.new("blablabla").byterindex(StringSpecs::MyString.new("bla")).should == 6

- end

- it "starts the search at the given offset" do

- "blablabla".byterindex("bl", 0).should == 0

- "blablabla".byterindex("bl", 1).should == 0

- "blablabla".byterindex("bl", 2).should == 0

- "blablabla".byterindex("bl", 3).should == 3

-

- "blablabla".byterindex("bla", 0).should == 0

- "blablabla".byterindex("bla", 1).should == 0

- "blablabla".byterindex("bla", 2).should == 0

- "blablabla".byterindex("bla", 3).should == 3

-

- "blablabla".byterindex("blab", 0).should == 0

- "blablabla".byterindex("blab", 1).should == 0

- "blablabla".byterindex("blab", 2).should == 0

- "blablabla".byterindex("blab", 3).should == 3

- "blablabla".byterindex("blab", 6).should == 3

- "blablablax".byterindex("blab", 6).should == 3

-

- "blablabla".byterindex("la", 1).should == 1

- "blablabla".byterindex("la", 2).should == 1

- "blablabla".byterindex("la", 3).should == 1

- "blablabla".byterindex("la", 4).should == 4

-

- "blablabla".byterindex("lab", 1).should == 1

- "blablabla".byterindex("lab", 2).should == 1

- "blablabla".byterindex("lab", 3).should == 1

- "blablabla".byterindex("lab", 4).should == 4

-

- "blablabla".byterindex("ab", 2).should == 2

- "blablabla".byterindex("ab", 3).should == 2

- "blablabla".byterindex("ab", 4).should == 2

- "blablabla".byterindex("ab", 5).should == 5

-

- "blablabla".byterindex("", 0).should == 0

- "blablabla".byterindex("", 1).should == 1

- "blablabla".byterindex("", 2).should == 2

- "blablabla".byterindex("", 7).should == 7

- "blablabla".byterindex("", 8).should == 8

- "blablabla".byterindex("", 9).should == 9

- "blablabla".byterindex("", 10).should == 9

- end

- it "starts the search at offset + self.length if offset is negative" do

- str = "blablabla"

- ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|

- (-str.length .. -1).each do |offset|

- str.byterindex(needle, offset).should ==

- str.byterindex(needle, offset + str.length)

- end

- it "returns nil if the substring isn't found" do

- "blablabla".byterindex("B").should == nil

- "blablabla".byterindex("z").should == nil

- "blablabla".byterindex("BLA").should == nil

- "blablabla".byterindex("blablablabla").should == nil

- "hello".byterindex("lo", 0).should == nil

- "hello".byterindex("lo", 1).should == nil

- "hello".byterindex("lo", 2).should == nil

- "hello".byterindex("llo", 0).should == nil

- "hello".byterindex("llo", 1).should == nil

- "hello".byterindex("el", 0).should == nil

- "hello".byterindex("ello", 0).should == nil

- "hello".byterindex("", -6).should == nil

- "hello".byterindex("", -7).should == nil

- "hello".byterindex("h", -6).should == nil

- end

- it "tries to convert start_offset to an integer via to_int" do

- obj = mock('5')

- def obj.to_int() 5 end

- "str".byterindex("st", obj).should == 0

- obj = mock('5')

- def obj.respond_to?(arg, *) true end

- def obj.method_missing(*args) 5 end

- "str".byterindex("st", obj).should == 0

- end

- it "raises a TypeError when given offset is nil" do

- -> { "str".byterindex("st", nil) }.should raise_error(TypeError)

- end

- it "handles a substring in a superset encoding" do

- 'abc'.dup.force_encoding(Encoding::US_ASCII).byterindex('é').should == nil

- end