+describe "Array#deconstruct" do

+ it "returns self" do

+ array = [1]

+ array.deconstruct.should equal array

+describe "Array#[]= with [..n] and [...n]" do

+ it "just sets the section defined by range to nil even if the rhs is nil" do

+ a = [1, 2, 3, 4, 5]

+ a[(..2)] = nil

+ a.should == [nil, 4, 5]

+ a[(...2)] = nil

+ a.should == [nil, 5]

+ end

+ it "just sets the section defined by range to nil if n < 0 and the rhs is nil" do

+ a = [1, 2, 3, 4, 5]

+ a[(..-3)] = nil

+ a.should == [nil, 4, 5]

+ a[(...-1)] = [nil, 5]

+ end

+ it "replaces the section defined by range" do

+ a = [6, 5, 4, 3, 2, 1]

+ a[(...3)] = 9

+ a.should == [9, 3, 2, 1]

+ a[(..2)] = [7, 7, 7, 7, 7]

+ a.should == [7, 7, 7, 7, 7, 1]

+ end

+ it "replaces the section if n < 0" do

+ a = [1, 2, 3, 4, 5]

+ a[(..-2)] = [7, 8, 9]

+ a.should == [7, 8, 9, 5]

+ end

+ it "replaces everything if n > the array size" do

+ a = [1, 2, 3]

+ a[(...7)] = [4]

+ a.should == [4]

+ end

+ it "inserts at the beginning if n < negative the array size" do

+ a = [1, 2, 3]

+ a[(..-7)] = [4]

+ a.should == [4, 1, 2, 3]

+ a[(...-10)] = [6]

+ a.should == [6, 4, 1, 2, 3]

+ it "works with beginless ranges" do

+ [1, 2, 3, 4].fill('x', (..2)).should == ["x", "x", "x", 4]

+ [1, 2, 3, 4].fill((...2)) { |x| x + 2 }.should == [2, 3, 3, 4]

+describe "Array#intersection" do

+ it_behaves_like :array_intersection, :intersection

+ it "accepts multiple arguments" do

+ [1, 2, 3, 4].intersection([1, 2, 3], [2, 3, 4]).should == [2, 3]

+ end

+ it "preserves elements order from original array" do

+ [1, 2, 3, 4].intersection([3, 2, 1]).should == [1, 2, 3]

+ context "when $, is not nil" do

+ before do

+ suppress_warning do

+ $, = '*'

+ end

+ it "warns" do

+ -> { [].join }.should complain(/warning: \$, is set to non-nil value/)

+ -> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)

+ @array.send(@method, (..0).step(1)).should == [0]

+ @array.send(@method, (...0).step(1)).should == []

+ @array.send(@method, (..0).step(2)).should == [0]

+ @array.send(@method, (...0).step(2)).should == []

+ @array.send(@method, (..0).step(10)).should == [0]

+ @array.send(@method, (...0).step(10)).should == []

+ @array.send(@method, (..3).step(1)).should == [0, 1, 2, 3]

+ @array.send(@method, (...3).step(1)).should == [0, 1, 2]

+ @array.send(@method, (..3).step(2)).should == [0, 2]

+ @array.send(@method, (...3).step(2)).should == [0, 2]

+ @array.send(@method, (..3).step(10)).should == [0]

+ @array.send(@method, (...3).step(10)).should == [0]

+ @array.send(@method, (..-2).step(1)).should == [0, 1, 2, 3, 4,]

+ @array.send(@method, (...-2).step(1)).should == [0, 1, 2, 3]

+ @array.send(@method, (..-2).step(2)).should == [0, 2, 4]

+ @array.send(@method, (...-2).step(2)).should == [0, 2]

+ @array.send(@method, (..-2).step(10)).should == [0]

+ @array.send(@method, (...-2).step(10)).should == [0]

+ it "can accept beginless ranges" do

+ a = [0, 1, 2, 3, 4, 5]

+ a.send(@method, (..3)).should == [0, 1, 2, 3]

+ a.send(@method, (...3)).should == [0, 1, 2]

+ a.send(@method, (..-3)).should == [0, 1, 2, 3]

+ a.send(@method, (...-3)).should == [0, 1, 2]

+ a.send(@method, (..0)).should == [0]

+ a.send(@method, (...0)).should == []

+ a.send(@method, (..9)).should == [0, 1, 2, 3, 4, 5]

+ a.send(@method, (...9)).should == [0, 1, 2, 3, 4, 5]

+ a.send(@method, (..-9)).should == []

+ a.send(@method, (...-9)).should == []

+ end

+

+ it "can accept nil...nil ranges" do

+ a = [0, 1, 2, 3, 4, 5]

+ a.send(@method, eval("(nil...nil)")).should == a

+ a.send(@method, (...nil)).should == a

+ a.send(@method, eval("(nil..)")).should == a

+ it "works with beginless ranges" do

+ a = [0,1,2,3,4]

+ a.slice!((..3)).should == [0, 1, 2, 3]

+ a.should == [4]

+

+ a = [0,1,2,3,4]

+ a.slice!((...-2)).should == [0, 1, 2]

+ a.should == [3, 4]

+ it "compares elements with matching hash codes with #eql?" do

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+ def obj.eql?(o)

+ false

+ obj

+ a.uniq.should == a

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+ def obj.eql?(o)

+ true

+ obj

+

+ a.uniq.size.should == 1

+ it "works when given beginless ranges" do

+ [1, 2, 3, 4].values_at((..2)).should == [1, 2, 3]

+ [1, 2, 3, 4].values_at((...2)).should == [1, 2]

+ it "is a String" do

+ RUBY_REVISION.should be_kind_of(String)

+ it 'returns self if within the given range parameters' do

+ one = ComparableSpecs::WithOnlyCompareDefined.new(1)

+ two = ComparableSpecs::WithOnlyCompareDefined.new(2)

+ three = ComparableSpecs::WithOnlyCompareDefined.new(3)

+ c = ComparableSpecs::Weird.new(2)

+

+ c.clamp(one..two).should equal(c)

+ c.clamp(two..two).should equal(c)

+ c.clamp(one..three).should equal(c)

+ c.clamp(two..three).should equal(c)

+ end

+

+ it 'returns the minimum value of the range parameters if smaller than it' do

+ one = ComparableSpecs::WithOnlyCompareDefined.new(1)

+ two = ComparableSpecs::WithOnlyCompareDefined.new(2)

+ c = ComparableSpecs::Weird.new(0)

+

+ c.clamp(one..two).should equal(one)

+ end

+

+ it 'returns the maximum value of the range parameters if greater than it' do

+ one = ComparableSpecs::WithOnlyCompareDefined.new(1)

+ two = ComparableSpecs::WithOnlyCompareDefined.new(2)

+ c = ComparableSpecs::Weird.new(3)

+

+ c.clamp(one..two).should equal(two)

+ end

+

+ it 'raises an Argument error if the range parameter is exclusive' do

+ one = ComparableSpecs::WithOnlyCompareDefined.new(1)

+ two = ComparableSpecs::WithOnlyCompareDefined.new(2)

+ c = ComparableSpecs::Weird.new(3)

+

+ -> { c.clamp(one...two) }.should raise_error(ArgumentError)

+ it "returns nil if either self or argument has imaginary part" do

+ (Complex(5, 1) <=> Complex(2)).should be_nil

+ (Complex(1) <=> Complex(2, 1)).should be_nil

+ (5 <=> Complex(2, 1)).should be_nil

+ end

+ it "returns nil if argument is not numeric" do

+ (Complex(5, 1) <=> "cmp").should be_nil

+ (Complex(1) <=> "cmp").should be_nil

+ (Complex(1) <=> Object.new).should be_nil

+ end

+ it "returns 0, 1, or -1 if self and argument do not have imaginary part" do

+ (Complex(5) <=> Complex(2)).should == 1

+ (Complex(2) <=> Complex(3)).should == -1

+ (Complex(2) <=> Complex(2)).should == 0

+ (Complex(5) <=> 2).should == 1

+ (Complex(2) <=> 3).should == -1

+ (Complex(2) <=> 2).should == 0

+ it "raises an ArgumentError if the string contains \\0" do

+ -> {Dir.send(@method, "file_o*\0file_t*")}.should raise_error ArgumentError, /nul-separated/

+ it 'includes CESU-8 encoding' do

+ Encoding.list.should.include?(Encoding::CESU_8)

+describe 'Enumerable#filter_map' do

+ before :each do

+ @numerous = EnumerableSpecs::Numerous.new(*(1..8).to_a)

+ end

+ it 'returns an empty array if there are no elements' do

+ EnumerableSpecs::Empty.new.filter_map { true }.should == []

+ end

+ it 'returns an array with truthy results of passing each element to block' do

+ @numerous.filter_map { |i| i * 2 if i.even? }.should == [4, 8, 12, 16]

+ @numerous.filter_map { |i| i * 2 }.should == [2, 4, 6, 8, 10, 12, 14, 16]

+ @numerous.filter_map { 0 }.should == [0, 0, 0, 0, 0, 0, 0, 0]

+ @numerous.filter_map { false }.should == []

+ @numerous.filter_map { nil }.should == []

+ end

+ it 'returns an enumerator when no block given' do

+ @numerous.filter_map.should be_an_instance_of(Enumerator)

+ EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-) { raise "we never get here"}.should == 4

+ [].send(@method, 3, :+) { raise "we never get here"}.should == 3

+describe "Enumerable#tally" do

+ before :each do

+ ScratchPad.record []

+ end

+ it "returns a hash with counts according to the value" do

+ enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')

+ enum.tally.should == { 'foo' => 2, 'bar' => 1, 'baz' => 1}

+ end

+ it "returns a hash without default" do

+ hash = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz').tally

+ hash.default_proc.should be_nil

+ hash.default.should be_nil

+ end

+ it "returns an empty hash for empty enumerables" do

+ EnumerableSpecs::Empty.new.tally.should == {}

+ end

+ it "counts values as gathered array when yielded with multiple arguments" do

+ EnumerableSpecs::YieldsMixed2.new.tally.should == EnumerableSpecs::YieldsMixed2.gathered_yields.group_by(&:itself).transform_values(&:size)

+ end

+ it "does not call given block" do

+ enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')

+ enum.tally { |v| ScratchPad << v }

+ ScratchPad.recorded.should == []

+ it "compares elements with matching hash codes with #eql?" do

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+ def obj.eql?(o)

+ false

+ obj

+ a.uniq.should == a

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+ def obj.eql?(o)

+ true

+ obj

+

+ a.to_enum.uniq.size.should == 1

+ context "with beginless" do

+ it "returns nil as begin of the sequence" do

+ (..10).step(1).begin.should == nil

+ (...10).step(1).begin.should == nil

+describe "Enumerator::Lazy#eager" do

+ it "returns a non-lazy Enumerator converted from the lazy enumerator" do

+ enum = [1, 2, 3].lazy

+ enum.class.should == Enumerator::Lazy

+ enum.eager.class.should == Enumerator

+ end

+ it "does not enumerate an enumerator" do

+ ScratchPad.record []

+ sequence = [1, 2, 3]

+ enum_lazy = Enumerator::Lazy.new(sequence) do |yielder, value|

+ yielder << value

+ ScratchPad << value

+ end

+ ScratchPad.recorded.should == []

+ enum = enum_lazy.eager

+ ScratchPad.recorded.should == []

+ enum.map { |i| i }.should == [1, 2, 3]

+ ScratchPad.recorded.should == [1, 2, 3]

+describe "Enumerator::Lazy#filter_map" do

+ it "maps only truthy results" do

+ (1..Float::INFINITY).lazy.filter_map { |i| i if i.odd? }.first(4).should == [1, 3, 5, 7]

+ end

+ it "does not map false results" do

+ (1..Float::INFINITY).lazy.filter_map { |i| i.odd? ? i : false }.first(4).should == [1, 3, 5, 7]

+describe "Enumerator::Lazy#with_index" do

+ it "enumerates with an index" do

+ (0..Float::INFINITY).lazy.with_index.map { |i, idx| [i, idx] }.first(3).should == [[0, 0], [1, 1], [2, 2]]

+ end

+ it "enumerates with an index starting at a given offset" do

+ (0..Float::INFINITY).lazy.with_index(3).map { |i, idx| [i, idx] }.first(3).should == [[0, 3], [1, 4], [2, 5]]

+ end

+ it "enumerates with an index starting at 0 when offset is nil" do

+ (0..Float::INFINITY).lazy.with_index(nil).map { |i, idx| [i, idx] }.first(3).should == [[0, 0], [1, 1], [2, 2]]

+ end

+ it "raises TypeError when offset does not convert to Integer" do

+ -> { (0..Float::INFINITY).lazy.with_index(false).map { |i, idx| i }.first(3) }.should raise_error(TypeError)

+ end

+ it "enumerates with a given block" do

+ result = []

+ (0..Float::INFINITY).lazy.with_index { |i, idx| result << [i * 2, idx] }.first(3)

+ result.should == [[0,0],[2,1],[4,2]]

+ end

+ it "resets after a new call to each" do

+ enum = (0..2).lazy.with_index.map { |i, idx| [i, idx] }

+ result = []

+ enum.each { |i, idx| result << [i, idx] }

+ enum.each { |i, idx| result << [i, idx] }

+ result.should == [[0,0], [1,1], [2,2], [0,0], [1,1], [2,2]]

+ it "defines iteration with block, yielder argument and treating it as a proc" do

+ enum = Enumerator.new do |yielder|

+ "a\nb\nc".each_line(&yielder)

+

+ enum.to_a.should == ["a\n", "b\n", "c"]

+describe "Enumerator.produce" do

+ it "creates an infinite enumerator" do

+ enum = Enumerator.produce(0) { |prev| prev + 1 }

+ enum.take(5).should == [0, 1, 2, 3, 4]

+ end

+ it "terminates iteration when block raises StopIteration exception" do

+ enum = Enumerator.produce(0) do | prev|

+ raise StopIteration if prev >= 2

+ prev + 1

+ enum.to_a.should == [0, 1, 2]

+ end

+

+ context "when initial value skipped" do

+ it "uses nil instead" do

+ ScratchPad.record []

+ enum = Enumerator.produce { |prev| ScratchPad << prev; (prev || 0) + 1 }

+ enum.take(3).should == [1, 2, 3]

+ ScratchPad.recorded.should == [nil, 1, 2]

+ end

+ it "starts enumerable from result of first block call" do

+ array = "a\nb\nc\nd".lines

+ lines = Enumerator.produce { array.shift }.take_while { |s| s }

+ lines.should == ["a\n", "b\n", "c\n", "d"]

+describe "Enumerator::Yielder#to_proc" do

+ it "returns a Proc object that takes an argument and yields it to the block" do

+ ScratchPad.record []

+ y = Enumerator::Yielder.new { |*args| ScratchPad << args; "foobar" }

+ callable = y.to_proc

+ callable.class.should == Proc

+ result = callable.call(1, 2)

+ ScratchPad.recorded.should == [[1, 2]]

+ result.should == "foobar"

+describe "ENV.merge!" do

+ it_behaves_like :env_update, :merge!

+ # BUG: https://bugs.ruby-lang.org/issues/16192

+ it "does not evaluate the block when the name is new" do

+ ENV.delete("bar")

+ ENV.send @method, {"foo" => "0"}

+ ENV.send(@method, "bar" => "1") { |key, old, new| fail "Should not get here" }

+ ENV["bar"].should == "1"

+ end

+ # BUG: https://bugs.ruby-lang.org/issues/16192

+ it "does not use the block's return value as the value when the name is new" do

+ ENV.delete("bar")

+ ENV.send @method, {"foo" => "0"}

+ ENV.send(@method, "bar" => "1") { |key, old, new| "Should not use this value" }

+ ENV["foo"].should == "0"

+ ENV["bar"].should == "1"

+ it "should take optional receiver argument" do

+ o = Object.new

+ FrozenError.new("msg", receiver: o).receiver.should equal(o)

+ it "should return frozen object that modification was attempted on" do

+ o = Object.new.freeze

+ begin

+ def o.x; end

+ rescue => e

+ e.should be_kind_of(FrozenError)

+ e.receiver.should equal(o)

+ else

+ raise

+ it "returns a frozen string" do

+ false.to_s.should.frozen?

+ end

+ it "always returns the same string" do

+ false.to_s.should equal(false.to_s)

+describe "Fiber#raise" do

+ it_behaves_like :kernel_raise, :raise, FiberSpecs::NewFiberToRaise

+end

+

+describe "Fiber#raise" do

+ it 'raises RuntimeError by default' do

+ -> { FiberSpecs::NewFiberToRaise.raise }.should raise_error(RuntimeError)

+ it "raises FiberError if Fiber is not born" do

+ fiber = Fiber.new { true }

+ -> { fiber.raise }.should raise_error(FiberError, "cannot raise exception on unborn fiber")

+ end

+ it "raises FiberError if Fiber is dead" do

+ fiber = Fiber.new { true }

+ fiber.resume

+ -> { fiber.raise }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)

+ end

+ it 'accepts error class' do

+ -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError }.should raise_error(FiberSpecs::CustomError)

+ end

+ it 'accepts error message' do

+ -> { FiberSpecs::NewFiberToRaise.raise "error message" }.should raise_error(RuntimeError, "error message")

+ end

+ it 'does not accept array of backtrace information only' do

+ -> { FiberSpecs::NewFiberToRaise.raise ['foo'] }.should raise_error(TypeError)

+ end

+ it 'does not accept integer' do

+ -> { FiberSpecs::NewFiberToRaise.raise 100 }.should raise_error(TypeError)

+ end

+ it 'accepts error class with error message' do

+ -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error' }.should raise_error(FiberSpecs::CustomError, 'test error')

+ end

+ it 'accepts error class with with error message and backtrace information' do

+ -> {

+ FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error', ['foo', 'boo']

+ }.should raise_error(FiberSpecs::CustomError) { |e|

+ e.message.should == 'test error'

+ e.backtrace.should == ['foo', 'boo']

+ }

+ end

+ it 'does not accept only error message and backtrace information' do

+ -> { FiberSpecs::NewFiberToRaise.raise 'test error', ['foo', 'boo'] }.should raise_error(TypeError)

+ end

+ it "raises a FiberError if invoked from a different Thread" do

+ fiber = Fiber.new { Fiber.yield }

+ fiber.resume

+ Thread.new do

+ -> {

+ fiber.raise

+ }.should raise_error(FiberError, "fiber called across threads")

+ end.join

+ end

+ it "kills Fiber" do

+ fiber = Fiber.new { Fiber.yield :first; :second }

+ fiber.resume

+ -> { fiber.raise }.should raise_error

+ -> { fiber.resume }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)

+ end

+ it "returns to calling fiber after raise" do

+ fiber_one = Fiber.new do

+ Fiber.yield :yield_one

+ :unreachable

+ fiber_two = Fiber.new do

+ results = []

+ results << fiber_one.resume

+ begin

+ fiber_one.raise

+ rescue

+ results << :rescued

+ results

+ fiber_two.resume.should == [:yield_one, :rescued]

+ end

+

+ruby_version_is ""..."3.0" do

+describe "File.absolute_path?" do

+ before :each do

+ @abs = File.expand_path(__FILE__)

+ end

+ it "returns true if it's an absolute pathname" do

+ File.absolute_path?(@abs).should be_true

+ end

+ it "returns false if it's a relative path" do

+ File.absolute_path?(File.basename(__FILE__)).should be_false

+ end

+ it "returns false if it's a tricky relative path" do

+ File.absolute_path?("C:foo\\bar").should be_false

+ end

+ it "does not expand '~' to a home directory." do

+ File.absolute_path?('~').should be_false

+ end

+ it "does not expand '~user' to a home directory." do

+ path = File.dirname(@abs)

+ Dir.chdir(path) do

+ File.absolute_path?('~user').should be_false

+ end

+ it "calls #to_path on its argument" do

+ mock = mock_to_path(File.expand_path(__FILE__))

+ File.absolute_path?(mock).should be_true

+ end

+ platform_is_not :windows do

+ it "takes into consideration the platform's root" do

+ File.absolute_path?("C:\\foo\\bar").should be_false

+ File.absolute_path?("C:/foo/bar").should be_false

+ File.absolute_path?("/foo/bar\\baz").should be_true

+ end

+ platform_is :windows do

+ it "takes into consideration the platform path separator(s)" do

+ File.absolute_path?("C:\\foo\\bar").should be_true

+ File.absolute_path?("C:/foo/bar").should be_true

+ File.absolute_path?("/foo/bar\\baz").should be_false

+ platform_is :windows do

+ platform_is_not :windows do

+ it "raises for elements that are not arrays" do

+ -> {

+ Hash[[:a]].should == {}

+ }.should raise_error(ArgumentError)

+ -> {

+ Hash[[:nil]].should == {}

+ }.should raise_error(ArgumentError)

+describe "Hash#deconstruct_keys" do

+ it "returns self" do

+ hash = {a: 1, b: 2}

+ hash.deconstruct_keys([:a, :b]).should equal hash

+ end

+ it "requires one argument" do

+ -> {

+ {a: 1}.deconstruct_keys

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

+ end

+ it "ignores argument" do

+ hash = {a: 1, b: 2}

+ hash.deconstruct_keys([:a]).should == {a: 1, b: 2}

+ hash.deconstruct_keys(0 ).should == {a: 1, b: 2}

+ hash.deconstruct_keys('' ).should == {a: 1, b: 2}

+describe "Hash.ruby2_keywords_hash?" do

+ it "returns false if the Hash is not a keywords Hash" do

+ Hash.ruby2_keywords_hash?({}).should == false

+ end

+

+ it "returns true if the Hash is a keywords Hash marked by Module#ruby2_keywords" do

+ obj = Class.new {

+ ruby2_keywords def m(*args)

+ args.last

+ end

+ }.new

+ Hash.ruby2_keywords_hash?(obj.m(a: 1)).should == true

+ end

+

+ it "raises TypeError for non-Hash" do

+ -> { Hash.ruby2_keywords_hash?(nil) }.should raise_error(TypeError)

+ end

+end

+

+describe "Hash.ruby2_keywords_hash" do

+ it "returns a copy of a Hash and marks the copy as a keywords Hash" do

+ h = {a: 1}.freeze

+ kw = Hash.ruby2_keywords_hash(h)

+ Hash.ruby2_keywords_hash?(h).should == false

+ Hash.ruby2_keywords_hash?(kw).should == true

+ kw.should == h

+ end

+

+ it "returns an instance of the subclass if called on an instance of a subclass of Hash" do

+ h = HashSpecs::MyHash.new

+ h[:a] = 1

+ kw = Hash.ruby2_keywords_hash(h)

+ kw.class.should == HashSpecs::MyHash

+ Hash.ruby2_keywords_hash?(h).should == false

+ Hash.ruby2_keywords_hash?(kw).should == true

+ kw.should == h

+ end

+

+ it "copies instance variables" do

+ h = {a: 1}

+ h.instance_variable_set(:@foo, 42)

+ kw = Hash.ruby2_keywords_hash(h)

+ kw.instance_variable_get(:@foo).should == 42

+ end

+

+ it "copies the hash internals" do

+ h = {a: 1}

+ kw = Hash.ruby2_keywords_hash(h)

+ h[:a] = 2

+ kw[:a].should == 1

+ end

+

+ it "raises TypeError for non-Hash" do

+ -> { Hash.ruby2_keywords_hash(nil) }.should raise_error(TypeError)

+ # Why isn't this true of eql? too ?

+ it "compares keys with matching hash codes via eql?" do

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+

+ def obj.eql?(o)

+ return true if self.equal?(o)

+ false

+ obj

+ { a[0] => 1 }.send(@method, { a[1] => 1 }).should be_false

+ a = Array.new(2) do

+ obj = mock('0')

+ obj.should_receive(:hash).at_least(1).and_return(0)

+ def obj.eql?(o)

+ true

+ obj

+

+ { a[0] => 1 }.send(@method, { a[1] => 1 }).should be_true

+ ruby_version_is ''...'3.0' do

+ it 'returns a String encoding self interpreted as a codepoint in the CESU-8 encoding' do

+ # see more details here https://en.wikipedia.org/wiki/CESU-8

+ # code points from U+0000 to U+FFFF is encoded in the same way as in UTF-8

+ 0x0045.chr(Encoding::CESU_8).bytes.should == 0x0045.chr(Encoding::UTF_8).bytes

+

+ # code points in range from U+10000 to U+10FFFF is CESU-8 data containing a 6-byte surrogate pair,

+ # which decodes to a 4-byte UTF-8 string

+ 0x10400.chr(Encoding::CESU_8).bytes.should != 0x10400.chr(Encoding::UTF_8).bytes

+ 0x10400.chr(Encoding::CESU_8).bytes.to_a.should == [0xED, 0xA0, 0x81, 0xED, 0xB0, 0x80]

+ context "when index and length passed" do

+ it "returns specified number of bits from specified position" do

+ 0b101001101[2, 4].should == 0b0011

+ 0b101001101[2, 5].should == 0b10011

+ 0b101001101[2, 7].should == 0b1010011

+ end

+ it "ensures n[i, len] equals to (n >> i) & ((1 << len) - 1)" do

+ n = 0b101001101; i = 2; len = 4

+ n[i, len].should == (n >> i) & ((1 << len) - 1)

+ end

+ it "moves start position to the most significant bits when negative index passed" do

+ 0b000001[-1, 4].should == 0b10

+ 0b000001[-2, 4].should == 0b100

+ 0b000001[-3, 4].should == 0b1000

+ end

+ it "ignores negative length" do

+ 0b101001101[1, -1].should == 0b10100110

+ 0b101001101[2, -1].should == 0b1010011

+ 0b101001101[3, -1].should == 0b101001

+ 0b101001101[3, -5].should == 0b101001

+ 0b101001101[3, -15].should == 0b101001

+ 0b101001101[3, -125].should == 0b101001

+ end

+ context "when range passed" do

+ it "returns bits specified by range" do

+ 0b101001101[2..5].should == 0b0011

+ 0b101001101[2..6].should == 0b10011

+ 0b101001101[2..8].should == 0b1010011

+ end

+ it "ensures n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1)" do

+ n = 0b101001101; i = 2; j = 5

+ n[i..j].should == (n >> i) & ((1 << (j - i + 1)) - 1)

+ end

+ it "ensures n[i..] equals to (n >> i)" do

+ eval("0b101001101[3..]").should == 0b101001101 >> 3

+ end

+ it "moves lower boundary to the most significant bits when negative value passed" do

+ 0b000001[-1, 4].should == 0b10

+ 0b000001[-2, 4].should == 0b100

+ 0b000001[-3, 4].should == 0b1000

+ end

+ it "ignores upper boundary smaller than lower boundary" do

+ 0b101001101[4..1].should == 0b10100

+ 0b101001101[4..2].should == 0b10100

+ 0b101001101[-4..-5].should == 0b1010011010000

+ end

+

+ it "raises FloatDomainError if any boundary is infinity" do

+ -> { 0x0001[3..Float::INFINITY] }.should raise_error(FloatDomainError, /Infinity/)

+ -> { 0x0001[-Float::INFINITY..3] }.should raise_error(FloatDomainError, /-Infinity/)

+ end

+ context "when passed (..i)" do

+ it "returns 0 if all i bits equal 0" do

+ eval("0b10000[..1]").should == 0

+ eval("0b10000[..2]").should == 0

+ eval("0b10000[..3]").should == 0

+ it "raises ArgumentError if any of i bit equals 1" do

+ -> {

+ eval("0b111110[..3]")

+ }.should raise_error(ArgumentError, /The beginless range for Integer#\[\] results in infinity/)

+ it "performs floating-point division between self bignum and a bignum" do

+ num = 1000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146009

+ den = 2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

+ num.fdiv(den).should == 500.0

+ end

+

+ it "rounds to the correct value for bignums" do

+ den = 9 * 10**342

+

+ num = 1 * 10**344

+ num.fdiv(den).should == 11.11111111111111

+

+ num = 1 * 10**343

+ num.fdiv(den).should == 1.1111111111111112

+

+ num = 1 * 10**342

+ num.fdiv(den).should == 0.1111111111111111

+

+ num = 2 * 10**342

+ num.fdiv(den).should == 0.2222222222222222

+

+ num = 3 * 10**342

+ num.fdiv(den).should == 0.3333333333333333

+

+ num = 4 * 10**342

+ num.fdiv(den).should == 0.4444444444444444

+

+ num = 5 * 10**342

+ num.fdiv(den).should == 0.5555555555555556

+

+ num = 6 * 10**342

+ num.fdiv(den).should == 0.6666666666666666

+

+ num = 7 * 10**342

+ num.fdiv(den).should == 0.7777777777777778

+

+ num = 8 * 10**342

+ num.fdiv(den).should == 0.8888888888888888

+

+ num = 9 * 10**342

+ num.fdiv(den).should == 1.0

+

+ num = -5 * 10**342

+ num.fdiv(den).should == -0.5555555555555556

+ end

+

+ it "returns the result encoding if found BOM UTF-8 sequence" do

+ File.binwrite(@name, "\u{FEFF}abc")

+ @io.set_encoding_by_bom.should == Encoding::UTF_8

+ @io.external_encoding.should == Encoding::UTF_8

+ end

+ it "returns the result encoding if found BOM UTF_16LE sequence" do

+ File.binwrite(@name, "\xFF\xFEabc")

+ @io.set_encoding_by_bom.should == Encoding::UTF_16LE

+ @io.external_encoding.should == Encoding::UTF_16LE

+ end

+ it "returns the result encoding if found BOM UTF_16BE sequence" do

+ File.binwrite(@name, "\xFE\xFFabc")

+ @io.set_encoding_by_bom.should == Encoding::UTF_16BE

+ @io.external_encoding.should == Encoding::UTF_16BE

+ end

+ it "returns the result encoding if found BOM UTF_32LE sequence" do

+ File.binwrite(@name, "\xFF\xFE\x00\x00abc")

+ @io.set_encoding_by_bom.should == Encoding::UTF_32LE

+ @io.external_encoding.should == Encoding::UTF_32LE

+ end

+ it "returns the result encoding if found BOM UTF_32BE sequence" do

+ File.binwrite(@name, "\x00\x00\xFE\xFFabc")

+ @io.set_encoding_by_bom.should == Encoding::UTF_32BE

+ @io.external_encoding.should == Encoding::UTF_32BE

+ end

+ it "returns nil if found BOM sequence not provided" do

+ File.write(@name, "abc")

+ @io.set_encoding_by_bom.should == nil

+ end

+ it 'returns exception if io not in binary mode' do

+ not_binary_io = new_io(@name, 'r')

+ -> { not_binary_io.set_encoding_by_bom }.should raise_error(ArgumentError, 'ASCII incompatible encoding needs binmode')

+ ensure

+ not_binary_io.close

+ end

+ it 'returns exception if encoding already set' do

+ @io.set_encoding("utf-8")

+ -> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding is set to UTF-8 already')

+ end

+ it 'returns exception if encoding conversion is already set' do

+ @io.set_encoding(Encoding::UTF_8, Encoding::UTF_16BE)

+ -> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding conversion is set')

+ it "never raises RangeError" do

+ for i in [4095, 0x4f7574206f6620636861722072616e67ff] do

+ @io.ungetbyte(i).should be_nil

+ @io.getbyte.should == 255

+ it "works with beginless ranges" do

+ locations1 = caller_locations(0)

+ locations2 = caller_locations((...5))

+ locations2.map(&:to_s)[eval("(2..)")].should == locations1[(...5)].map(&:to_s)[eval("(2..)")]

+ it "works with beginless ranges" do

+ locations1 = KernelSpecs::CallerTest.locations(0)

+ locations2 = KernelSpecs::CallerTest.locations((..5))

+ locations2.map(&:to_s)[eval("(2..)")].should == locations1[(..5)].map(&:to_s)[eval("(2..)")]

+

+ it "can call a #method_missing accepting zero or one arguments" do

+ cls = Class.new do

+ def respond_to_missing?(name, *)

+ name == :foo or super

+ end

+ def method_missing

+ :no_args

+ end

+ end

+ m = cls.new.method(:foo)

+ -> { m.call }.should raise_error(ArgumentError)

+

+ cls = Class.new do

+ def respond_to_missing?(name, *)

+ name == :bar or super

+ end

+ def method_missing(m)

+ m

+ end

+ end

+ m = cls.new.method(:bar)

+ m.call.should == :bar

+ end

+ ruby_version_is ""..."3.0" do

+ ruby_bug "#16926", ""..."3.0" do

+ provided << 'ruby2_keywords'

+ ruby_version_is ""..."3.0" do

+ ruby_version_is ""..."3.0" do

+ ruby_version_is ""..."3.0" do

+ ruby_version_is ""..."3.0" do

+ ruby_version_is ""..."3.0" do

+ ruby_version_is ""..."3.0" do

+describe "main.ruby2_keywords" do

+ it "is the same as Object.ruby2_keywords" do

+ main = TOPLEVEL_BINDING.receiver

+ main.should have_private_method(:ruby2_keywords)

+ it "is undefined" do

+ # https://bugs.ruby-lang.org/issues/16294

+ -> { MatchData.allocate }.should raise_error(NoMethodError)

+

+ # negative index is larger than the number of match values

+ /(.)(.)(\d+)(\d)/.match("THX1138.")[-30, 2].should == nil

+

+ # length argument larger than number of match values is capped to match value length

+ /(.)(.)(\d+)(\d)/.match("THX1138.")[3, 10].should == %w|113 8|

+ it "returns a String containing method arguments" do

+ obj = MethodSpecs::Methods.new

+ obj.method(:zero).send(@method).should.include?("()")

+ obj.method(:one_req).send(@method).should.include?("(a)")

+ obj.method(:one_req_named).send(@method).should.include?("(a:)")

+ obj.method(:zero_with_block).send(@method).should.include?("(&blk)")

+ obj.method(:one_opt).send(@method).should.include?("(a=...)")

+ obj.method(:one_opt_named).send(@method).should.include?("(a: ...)")

+ obj.method(:zero_with_splat).send(@method).should.include?("(*a)")

+ obj.method(:zero_with_double_splat).send(@method).should.include?("(**a)")

+ obj.method(:one_req_one_opt_with_splat_and_block).send(@method).should.include?("(a, b=..., *c, &blk)")

+ ruby_bug '#17428', ''...'3.0' do

+ it "shows the metaclass and the owner for a Module instance method retrieved from a class" do

+ String.method(:include).inspect.should.start_with?("#<Method: #<Class:String>(Module)#include")

+ it "returns nil if an ancestor defined that autoload but recursion is disabled" do

+ ModuleSpecs::Autoload::Parent.autoload :InheritedAutoload, "inherited_autoload.rb"

+ ModuleSpecs::Autoload::Child.autoload?(:InheritedAutoload, false).should be_nil

+ end

+ it "returns the name of the file that will be loaded if recursion is disabled but the autoload is defined on the class itself" do

+ ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"

+ ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"

+ ModuleSpecs::Autoload.const_defined?("P").should be_true

+ describe "with dynamically assigned constants" do

+ it "searches a path in the immediate class or module first" do

+ ConstantSpecs::ClassA::CSL_CONST301 = :const301_1

+ ConstantSpecs::ClassA.const_source_location(:CSL_CONST301).should == [__FILE__, __LINE__ - 1]

+ ConstantSpecs::ModuleA::CSL_CONST301 = :const301_2

+ ConstantSpecs::ModuleA.const_source_location(:CSL_CONST301).should == [__FILE__, __LINE__ - 1]

+ ConstantSpecs::ParentA::CSL_CONST301 = :const301_3

+ ConstantSpecs::ParentA.const_source_location(:CSL_CONST301).should == [__FILE__, __LINE__ - 1]

+ ConstantSpecs::ContainerA::ChildA::CSL_CONST301 = :const301_5

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CSL_CONST301).should == [__FILE__, __LINE__ - 1]

+ end

+ it "searches a path in a module included in the immediate class before the superclass" do

+ ConstantSpecs::ParentB::CSL_CONST302 = :const302_1

+ ConstantSpecs::ModuleF::CSL_CONST302 = :const302_2

+ ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST302).should == [__FILE__, __LINE__ - 1]

+ it "searches a path in the superclass before a module included in the superclass" do

+ ConstantSpecs::ModuleE::CSL_CONST303 = :const303_1

+ ConstantSpecs::ParentB::CSL_CONST303 = :const303_2

+ ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST303).should == [__FILE__, __LINE__ - 1]

+ end

+ it "searches a path in a module included in the superclass" do

+ ConstantSpecs::ModuleA::CSL_CONST304 = :const304_1

+ ConstantSpecs::ModuleE::CSL_CONST304 = :const304_2

+ ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST304).should == [__FILE__, __LINE__ - 1]

+ end

+ it "searches a path in the superclass chain" do

+ ConstantSpecs::ModuleA::CSL_CONST305 = :const305

+ ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST305).should == [__FILE__, __LINE__ - 1]

+ end

+ it "returns path to a toplevel constant when the receiver is a Class" do

+ Object::CSL_CONST306 = :const306

+ ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST306).should == [__FILE__, __LINE__ - 1]

+ end

+ it "returns path to a toplevel constant when the receiver is a Module" do

+ Object::CSL_CONST308 = :const308

+ ConstantSpecs.const_source_location(:CSL_CONST308).should == [__FILE__, __LINE__ - 1]

+ ConstantSpecs::ModuleA.const_source_location(:CSL_CONST308).should == [__FILE__, __LINE__ - 2]

+ end

+ it "returns path to the updated value of a constant" do

+ ConstantSpecs::ClassB::CSL_CONST309 = :const309_1

+ ConstantSpecs::ClassB.const_source_location(:CSL_CONST309).should == [__FILE__, __LINE__ - 1]

+ -> {

+ ConstantSpecs::ClassB::CSL_CONST309 = :const309_2

+ }.should complain(/already initialized constant/)

+ ConstantSpecs::ClassB.const_source_location(:CSL_CONST309).should == [__FILE__, __LINE__ - 2]

+ end

+ describe "with statically assigned constants" do

+ it "searches location path the immediate class or module first" do

+ ConstantSpecs::ClassA.const_source_location(:CS_CONST10).should == [@constants_fixture_path, ConstantSpecs::ClassA::CS_CONST10_LINE]

+ ConstantSpecs::ModuleA.const_source_location(:CS_CONST10).should == [@constants_fixture_path, ConstantSpecs::ModuleA::CS_CONST10_LINE]

+ ConstantSpecs::ParentA.const_source_location(:CS_CONST10).should == [@constants_fixture_path, ConstantSpecs::ParentA::CS_CONST10_LINE]

+ ConstantSpecs::ContainerA.const_source_location(:CS_CONST10).should == [@constants_fixture_path, ConstantSpecs::ContainerA::CS_CONST10_LINE]

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST10).should == [@constants_fixture_path, ConstantSpecs::ContainerA::ChildA::CS_CONST10_LINE]

+ it "searches location path a module included in the immediate class before the superclass" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST15).should == [@constants_fixture_path, ConstantSpecs::ModuleC::CS_CONST15_LINE]

+ it "searches location path the superclass before a module included in the superclass" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST11).should == [@constants_fixture_path, ConstantSpecs::ParentA::CS_CONST11_LINE]

+ it "searches location path a module included in the superclass" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST12).should == [@constants_fixture_path, ConstantSpecs::ModuleB::CS_CONST12_LINE]

+ it "searches location path the superclass chain" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST13).should == [@constants_fixture_path, ConstantSpecs::ModuleA::CS_CONST13_LINE]

+ it "returns location path a toplevel constant when the receiver is a Class" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST1).should == [@constants_fixture_path, CS_CONST1_LINE]

+ it "returns location path a toplevel constant when the receiver is a Module" do

+ ConstantSpecs.const_source_location(:CS_CONST1).should == [@constants_fixture_path, CS_CONST1_LINE]

+ ConstantSpecs::ModuleA.const_source_location(:CS_CONST1).should == [@constants_fixture_path, CS_CONST1_LINE]

+ end

+ it "return empty path if constant defined in C code" do

+ Object.const_source_location(:String).should == []

+ end

+ it "accepts a String or Symbol name" do

+ Object.const_source_location(:CS_CONST1).should == [@constants_fixture_path, CS_CONST1_LINE]

+ Object.const_source_location("CS_CONST1").should == [@constants_fixture_path, CS_CONST1_LINE]

+ end

+ it "returns nil if no constant is defined in the search path" do

+ ConstantSpecs.const_source_location(:CS_CONSTX).should == nil

+ end

+ it "raises a NameError if the name does not start with a capital letter" do

+ -> { ConstantSpecs.const_source_location "name" }.should raise_error(NameError)

+ end

+ it "raises a NameError if the name starts with a non-alphabetic character" do

+ -> { ConstantSpecs.const_source_location "__CONSTX__" }.should raise_error(NameError)

+ -> { ConstantSpecs.const_source_location "@CS_CONST1" }.should raise_error(NameError)

+ -> { ConstantSpecs.const_source_location "!CS_CONST1" }.should raise_error(NameError)

+ end

+ it "raises a NameError if the name contains non-alphabetic characters except '_'" do

+ Object.const_source_location("CS_CONST1").should == [@constants_fixture_path, CS_CONST1_LINE]

+ -> { ConstantSpecs.const_source_location "CS_CONST1=" }.should raise_error(NameError)

+ -> { ConstantSpecs.const_source_location "CS_CONST1?" }.should raise_error(NameError)

+ end

+ it "calls #to_str to convert the given name to a String" do

+ name = mock("ClassA")

+ name.should_receive(:to_str).and_return("ClassA")

+ ConstantSpecs.const_source_location(name).should == [@constants_fixture_path, ConstantSpecs::ClassA::CS_CLASS_A_LINE]

+ end

+ it "raises a TypeError if conversion to a String by calling #to_str fails" do

+ name = mock('123')

+ -> { ConstantSpecs.const_source_location(name) }.should raise_error(TypeError)

+ name.should_receive(:to_str).and_return(123)

+ -> { ConstantSpecs.const_source_location(name) }.should raise_error(TypeError)

+ end

+ it "does not search the singleton class of a Class or Module" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST14).should == nil

+ ConstantSpecs.const_source_location(:CS_CONST14).should == nil

+ end

+ it "does not search the containing scope" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST20).should == [@constants_fixture_path, ConstantSpecs::ParentA::CS_CONST20_LINE]

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST5) == nil

+ end

+ it "returns nil if the constant is defined in the receiver's superclass and the inherit flag is false" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST4, false).should == nil

+ end

+ it "searches into the receiver superclasses if the inherit flag is true" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST4, true).should == [@constants_fixture_path, ConstantSpecs::ParentA::CS_CONST4_LINE]

+ end

+ it "returns nil when the receiver is a Module, the constant is defined at toplevel and the inherit flag is false" do

+ ConstantSpecs::ModuleA.const_source_location(:CS_CONST1, false).should == nil

+ end

+ it "returns nil when the receiver is a Class, the constant is defined at toplevel and the inherit flag is false" do

+ ConstantSpecs::ContainerA::ChildA.const_source_location(:CS_CONST1, false).should == nil

+ end

+

+ it "accepts a toplevel scope qualifier" do

+ ConstantSpecs.const_source_location("::CS_CONST1").should == [@constants_fixture_path, CS_CONST1_LINE]

+ end

+

+ it "accepts a scoped constant name" do

+ ConstantSpecs.const_source_location("ClassA::CS_CONST10").should == [@constants_fixture_path, ConstantSpecs::ClassA::CS_CONST10_LINE]

+ end

+

+ it "returns updated location from const_set" do

+ mod = Module.new

+ const_line = __LINE__ + 1

+ mod.const_set :Foo, 1

+ mod.const_source_location(:Foo).should == [__FILE__, const_line]

+ end

+

+ it "raises a NameError if the name includes two successive scope separators" do

+ -> { ConstantSpecs.const_source_location("ClassA::::CS_CONST10") }.should raise_error(NameError)

+ end

+

+ it "raises a NameError if only '::' is passed" do

+ -> { ConstantSpecs.const_source_location("::") }.should raise_error(NameError)

+ end

+ it "raises a NameError if a Symbol has a toplevel scope qualifier" do

+ -> { ConstantSpecs.const_source_location(:'::CS_CONST1') }.should raise_error(NameError)

+ end

+ it "raises a NameError if a Symbol is a scoped constant name" do

+ -> { ConstantSpecs.const_source_location(:'ClassA::CS_CONST10') }.should raise_error(NameError)

+ end

+

+ it "does search private constants path" do

+ ConstantSpecs.const_source_location(:CS_PRIVATE).should == [@constants_fixture_path, ConstantSpecs::CS_PRIVATE_LINE]

+ end

+

+ context 'autoload' do

+ before :all do

+ ConstantSpecs.autoload :CSL_CONST1, "#{__dir__}/notexisting.rb"

+ @line = __LINE__ - 1

+ end

+

+ it 'returns the autoload location while not resolved' do

+ ConstantSpecs.const_source_location('CSL_CONST1').should == [__FILE__, @line]

+ end

+ it 'returns where the constant was resolved when resolved' do

+ file = fixture(__FILE__, 'autoload_location.rb')

+ ConstantSpecs.autoload :CONST_LOCATION, file

+ line = ConstantSpecs::CONST_LOCATION

+ ConstantSpecs.const_source_location('CONST_LOCATION').should == [file, line]

+ it "does not warn if Warning[:deprecated] is false" do

+ @module.deprecate_constant :PUBLIC1

+

+ deprecated = Warning[:deprecated]

+ begin

+ Warning[:deprecated] = false

+ -> { @module::PUBLIC1 }.should_not complain

+ ensure

+ Warning[:deprecated] = deprecated

+ it "returns a frozen String" do

+ ModuleSpecs.name.should.frozen?

+ it "always returns the same String for a given Module" do

+ s1 = ModuleSpecs.name

+ s2 = ModuleSpecs.name

+ s1.should equal(s2)

+ it "is honored by Kernel#method" do

+ klass = Class.new

+ refinement = Module.new do

+ refine klass do

+ def foo; end

+ result = nil

+ Module.new do

+ using refinement

+ result = klass.new.method(:foo).class

+ result.should == Method

+ it "is honored by Kernel#public_method" do

+ klass = Class.new

+ refinement = Module.new do

+ refine klass do

+ def foo; end

+ result = nil

+ Module.new do

+ using refinement

+ result = klass.new.public_method(:foo).class

+ result.should == Method

+ end

+ it "is honored by Kernel#instance_method" do

+ klass = Class.new

+ refinement = Module.new do

+ refine klass do

+ def foo; end

+ end

+ result = nil

+ Module.new do

+ using refinement

+ result = klass.instance_method(:foo).class

+

+ result.should == UnboundMethod

+describe "Module#ruby2_keywords" do

+ class << self

+ ruby2_keywords def mark(*args)

+ args

+ end

+ end

+ it "marks the final hash argument as keyword hash" do

+ last = mark(1, 2, a: "a").last

+ Hash.ruby2_keywords_hash?(last).should == true

+ end

+

+ it "makes a copy of the hash and only marks the copy as keyword hash" do

+ obj = Object.new

+ obj.singleton_class.class_exec do

+ def regular(*args)

+ args.last

+ end

+ h = {a: 1}

+ ruby_version_is "3.0" do

+ obj.regular(**h).should.equal?(h)

+ last = mark(**h).last

+ Hash.ruby2_keywords_hash?(last).should == true

+ Hash.ruby2_keywords_hash?(h).should == false

+ last2 = mark(**last).last # last is already marked

+ Hash.ruby2_keywords_hash?(last2).should == true

+ Hash.ruby2_keywords_hash?(last).should == true

+ last2.should_not.equal?(last)

+ Hash.ruby2_keywords_hash?(h).should == false

+ end

+ it "makes a copy and unmark the Hash when calling a method taking (arg)" do

+ obj = Object.new

+ obj.singleton_class.class_exec do

+ def single(arg)

+ arg

+ end

+ h = { a: 1 }

+ args = mark(**h)

+ marked = args.last

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

+

+ after_usage = obj.single(*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

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

+ obj = Object.new

+ obj.singleton_class.class_exec do

+ def kwargs(**kw)

+ kw

+ end

+ h = { a: 1 }

+ args = mark(**h)

+ marked = args.last

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

+

+ after_usage = obj.kwargs(*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

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

+ def splat(*args)

+ args.last

+ def splat1(arg, *args)

+ def proc_call(*args)

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

+ args = mark(**h)

+ after_usage = obj.splat(*args)

+ args = mark(1, **h)

+ marked = args.last

+ after_usage = obj.splat1(*args)

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

+ 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)

+ 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

+ 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.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

+ it "applies to the underlying method and applies across aliasing" do

+ obj = Object.new

+ obj.singleton_class.class_exec do

+ def foo(*a) a.last end

+ alias_method :bar, :foo

+ ruby2_keywords :foo

+ def baz(*a) a.last end

+ ruby2_keywords :baz

+ alias_method :bob, :baz

+ end

+ last = obj.foo(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+ last = obj.bar(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+ last = obj.baz(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+

+ last = obj.bob(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+ end

+

+ ruby_version_is ""..."3.0" do

+ it "fixes delegation warnings when calling a method accepting keywords" do

+ def foo(*a) bar(*a) end

+ def bar(*a, **b) end

+ end

+ -> { obj.foo(1, 2, {a: "a"}) }.should complain(/Using the last argument as keyword parameters is deprecated/)

+

+ obj.singleton_class.class_exec do

+ ruby2_keywords :foo

+

+ -> { obj.foo(1, 2, {a: "a"}) }.should_not complain

+ end

+ it "returns nil" do

+ obj = Object.new

+ obj.singleton_class.class_exec do

+ def foo(*a) end

+

+ ruby2_keywords(:foo).should == nil

+ end

+ it "raises NameError when passed not existing method name" do

+ obj = Object.new

+ -> {

+ ruby2_keywords :not_existing

+ }.should raise_error(NameError, /undefined method `not_existing'/)

+ end

+ it "accepts String as well" do

+ obj = Object.new

+

+ obj.singleton_class.class_exec do

+ def foo(*a) a.last end

+ ruby2_keywords "foo"

+ last = obj.foo(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+ end

+ it "raises TypeError when passed not Symbol or String" do

+ obj = Object.new

+ -> {

+ obj.singleton_class.class_exec do

+ ruby2_keywords Object.new

+ end

+ }.should raise_error(TypeError, /is not a symbol nor a string/)

+ end

+ it "prints warning when a method does not accept argument splat" do

+ obj = Object.new

+ def obj.foo(a, b, c) end

+ -> {

+ obj.singleton_class.class_exec do

+ ruby2_keywords :foo

+ end

+ }.should complain(/Skipping set of ruby2_keywords flag for/)

+ end

+ it "prints warning when a method accepts keywords" do

+ obj = Object.new

+ def obj.foo(a:, b:) end

+ -> {

+ obj.singleton_class.class_exec do

+ ruby2_keywords :foo

+ end

+ }.should complain(/Skipping set of ruby2_keywords flag for/)

+ end

+ it "prints warning when a method accepts keyword splat" do

+ obj = Object.new

+ def obj.foo(**a) end

+

+ -> {

+ obj.singleton_class.class_exec do

+ ruby2_keywords :foo

+ end

+ }.should complain(/Skipping set of ruby2_keywords flag for/)

+ it "returns a frozen string" do

+ nil.to_s.should.frozen?

+ end

+ it "always returns the same string" do

+ nil.to_s.should equal(nil.to_s)

+ it "accepts primitive or frozen keys or values" do

+ map = ObjectSpace::WeakMap.new

+ x = Object.new

+ should_accept(map, true, x)

+ should_accept(map, false, x)

+ should_accept(map, nil, x)

+ should_accept(map, 42, x)

+ should_accept(map, :foo, x)

+ should_accept(map, x, true)

+ should_accept(map, x, false)

+ should_accept(map, x, 42)

+ should_accept(map, x, :foo)

+ y = Object.new.freeze

+ should_accept(map, x, y)

+ should_accept(map, y, x)

+ it "reports true if the pair exists and the value is nil" do

+ map = ObjectSpace::WeakMap.new

+ key = Object.new

+ map[key] = nil

+ map.size.should == 1

+ map.send(@method, key).should == true

+ ruby_version_is ""..."3.0" do

+describe "Proc#ruby2_keywords" do

+ it "marks the final hash argument as keyword hash" do

+ f = -> *a { a.last }

+ f.ruby2_keywords

+ last = f.call(1, 2, a: "a")

+ Hash.ruby2_keywords_hash?(last).should == true

+ end

+ it "applies to the underlying method and applies across duplication" do

+ f1 = -> *a { a.last }

+ f1.ruby2_keywords

+ f2 = f1.dup

+ Hash.ruby2_keywords_hash?(f1.call(1, 2, a: "a")).should == true

+ Hash.ruby2_keywords_hash?(f2.call(1, 2, a: "a")).should == true

+ f3 = -> *a { a.last }

+ f4 = f3.dup

+ f3.ruby2_keywords

+ Hash.ruby2_keywords_hash?(f3.call(1, 2, a: "a")).should == true

+ Hash.ruby2_keywords_hash?(f4.call(1, 2, a: "a")).should == true

+ end