Update to ruby/spec@f8987ac

24 files changed, 616 insertions, 109 deletions

diff --git a/spec/ruby/core/array/each_spec.rb b/spec/ruby/core/array/each_spec.rb
index 57d6082f01..f4b5b758d0 100644
--- a/spec/ruby/core/array/each_spec.rb
+++ b/spec/ruby/core/array/each_spec.rb
@@ -7,7 +7,7 @@ require_relative '../enumerable/shared/enumeratorized'
 # Mutating the array while it is being iterated is discouraged as it can result in confusing behavior.
 # Yet a Ruby implementation must not crash in such a case, and following the simple CRuby behavior makes sense.
 # CRuby simply reads the array storage and checks the size for every iteration;
-# like `i = 0; while i < size; yield self[i]; end`
+# like `i = 0; while i < size; yield self[i]; i += 1; end`
 
 describe "Array#each" do
   it "yields each element to the block" do
diff --git a/spec/ruby/core/array/plus_spec.rb b/spec/ruby/core/array/plus_spec.rb
index 635bd131c9..b7153fd3ef 100644
--- a/spec/ruby/core/array/plus_spec.rb
+++ b/spec/ruby/core/array/plus_spec.rb
@@ -21,7 +21,7 @@ describe "Array#+" do
       ([1, 2, 3] + obj).should == [1, 2, 3, "x", "y"]
     end
 
-    it "raises a Typeerror if the given argument can't be converted to an array" do
+    it "raises a TypeError if the given argument can't be converted to an array" do
       -> { [1, 2, 3] + nil }.should raise_error(TypeError)
       -> { [1, 2, 3] + "abc" }.should raise_error(TypeError)
     end
diff --git a/spec/ruby/core/array/to_h_spec.rb b/spec/ruby/core/array/to_h_spec.rb
index f4578211a1..1c814f3d01 100644
--- a/spec/ruby/core/array/to_h_spec.rb
+++ b/spec/ruby/core/array/to_h_spec.rb
@@ -45,6 +45,12 @@ describe "Array#to_h" do
       [:a, :b].to_h { |k| [k, k.to_s] }.should == { a: 'a', b: 'b' }
     end
 
+    it "passes to a block each element as a single argument" do
+      ScratchPad.record []
+      [[:a, 1], [:b, 2]].to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [[[:a, 1]], [[:b, 2]]]
+    end
+
     it "raises ArgumentError if block returns longer or shorter array" do
       -> do
         [:a, :b].to_h { |k| [k, k.to_s, 1] }
diff --git a/spec/ruby/core/enumerable/shared/inject.rb b/spec/ruby/core/enumerable/shared/inject.rb
index 693d34d675..92f220efa4 100644
--- a/spec/ruby/core/enumerable/shared/inject.rb
+++ b/spec/ruby/core/enumerable/shared/inject.rb
@@ -16,6 +16,23 @@ describe :enumerable_inject, shared: true do
 
   it "can take two argument" do
     EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-).should == 4
+    EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, "-").should == 4
+
+    [1, 2, 3].send(@method, 10, :-).should == 4
+    [1, 2, 3].send(@method, 10, "-").should == 4
+  end
+
+  it "converts non-Symbol method name argument to String with #to_str if two arguments" do
+    name = Object.new
+    def name.to_str; "-"; end
+
+    EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, name).should == 4
+    [1, 2, 3].send(@method, 10, name).should == 4
+  end
+
+  it "raises TypeError when the second argument is not Symbol or String and it cannot be converted to String if two arguments" do
+    -> { EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, Object.new) }.should raise_error(TypeError, /is not a symbol nor a string/)
+    -> { [1, 2, 3].send(@method, 10, Object.new) }.should raise_error(TypeError, /is not a symbol nor a string/)
   end
 
   it "ignores the block if two arguments" do
@@ -39,6 +56,25 @@ describe :enumerable_inject, shared: true do
 
   it "can take a symbol argument" do
     EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, :-).should == 4
+    [10, 1, 2, 3].send(@method, :-).should == 4
+  end
+
+  it "can take a String argument" do
+    EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, "-").should == 4
+    [10, 1, 2, 3].send(@method, "-").should == 4
+  end
+
+  it "converts non-Symbol method name argument to String with #to_str" do
+    name = Object.new
+    def name.to_str; "-"; end
+
+    EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, name).should == 4
+    [10, 1, 2, 3].send(@method, name).should == 4
+  end
+
+  it "raises TypeError when passed not Symbol or String method name argument and it cannot be converted to String" do
+    -> { EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, Object.new) }.should raise_error(TypeError, /is not a symbol nor a string/)
+    -> { [10, 1, 2, 3].send(@method, Object.new) }.should raise_error(TypeError, /is not a symbol nor a string/)
   end
 
   it "without argument takes a block with an accumulator (with first element as initial value) and the current element. Value of block becomes new accumulator" do
@@ -77,7 +113,6 @@ describe :enumerable_inject, shared: true do
     EnumerableSpecs::EachDefiner.new('a','b','c').send(@method) {|result, i| i+result}.should == "cba"
     EnumerableSpecs::EachDefiner.new(3, 4, 5).send(@method) {|result, i| result*i}.should == 60
     EnumerableSpecs::EachDefiner.new([1], 2, 'a','b').send(@method){|r,i| r<<i}.should == [1, 2, 'a', 'b']
-
   end
 
   it "returns nil when fails(legacy rubycon)" do
diff --git a/spec/ruby/core/enumerable/to_h_spec.rb b/spec/ruby/core/enumerable/to_h_spec.rb
index 0489134552..11a4933c10 100644
--- a/spec/ruby/core/enumerable/to_h_spec.rb
+++ b/spec/ruby/core/enumerable/to_h_spec.rb
@@ -53,6 +53,14 @@ describe "Enumerable#to_h" do
       @enum.to_h { |k| [k, k.to_s] }.should == { a: 'a', b: 'b' }
     end
 
+    it "passes to a block each element as a single argument" do
+      enum_of_arrays = EnumerableSpecs::EachDefiner.new([:a, 1], [:b, 2])
+
+      ScratchPad.record []
+      enum_of_arrays.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [[[:a, 1]], [[:b, 2]]]
+    end
+
     it "raises ArgumentError if block returns longer or shorter array" do
       -> do
         @enum.to_h { |k| [k, k.to_s, 1] }
diff --git a/spec/ruby/core/env/to_h_spec.rb b/spec/ruby/core/env/to_h_spec.rb
index 3c4a92aa57..58ea2d2030 100644
--- a/spec/ruby/core/env/to_h_spec.rb
+++ b/spec/ruby/core/env/to_h_spec.rb
@@ -18,6 +18,18 @@ describe "ENV.to_h" do
       ENV.to_h { |k, v| [k, v.upcase] }.should == { 'a' => "B", 'c' => "D" }
     end
 
+    it "passes to a block each pair's key and value as separate arguments" do
+      ENV.replace("a" => "b", "c" => "d")
+
+      ScratchPad.record []
+      ENV.to_h { |k, v| ScratchPad << [k, v]; [k, v] }
+      ScratchPad.recorded.sort.should == [["a", "b"], ["c", "d"]]
+
+      ScratchPad.record []
+      ENV.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [["a", "b"], ["c", "d"]]
+    end
+
     it "does not require the array elements to be strings" do
       ENV.replace("a" => "b", "c" => "d")
       ENV.to_h { |k, v| [k.to_sym, v.to_sym] }.should == { :a => :b, :c => :d }
diff --git a/spec/ruby/core/exception/detailed_message_spec.rb b/spec/ruby/core/exception/detailed_message_spec.rb
index fbe4443daa..8178278b2b 100644
--- a/spec/ruby/core/exception/detailed_message_spec.rb
+++ b/spec/ruby/core/exception/detailed_message_spec.rb
@@ -15,14 +15,6 @@ describe "Exception#detailed_message" do
       exception.full_message(highlight: false).should.include? "<prefix>new error<suffix>"
     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 "allows and ignores other keyword arguments" do
-      RuntimeError.new("new error").detailed_message(foo: true).should == "new error (RuntimeError)"
-    end
-
     it "returns just a message if exception class is anonymous" do
       Class.new(RuntimeError).new("message").detailed_message.should == "message"
     end
@@ -31,13 +23,30 @@ describe "Exception#detailed_message" do
       RuntimeError.new("").detailed_message.should == "unhandled exception"
     end
 
-    it "returns just class name for an instance of RuntimeError subclass with empty message" do
+    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
   end
 end
diff --git a/spec/ruby/core/hash/replace_spec.rb b/spec/ruby/core/hash/replace_spec.rb
index 92b2118fd3..a26a31f5f9 100644
--- a/spec/ruby/core/hash/replace_spec.rb
+++ b/spec/ruby/core/hash/replace_spec.rb
@@ -1,7 +1,70 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
-require_relative 'shared/replace'
 
 describe "Hash#replace" do
-  it_behaves_like :hash_replace, :replace
+  it "replaces the contents of self with other" do
+    h = { a: 1, b: 2 }
+    h.replace(c: -1, d: -2).should equal(h)
+    h.should == { c: -1, d: -2 }
+  end
+
+  it "tries to convert the passed argument to a hash using #to_hash" do
+    obj = mock('{1=>2,3=>4}')
+    obj.should_receive(:to_hash).and_return({ 1 => 2, 3 => 4 })
+
+    h = {}
+    h.replace(obj)
+    h.should == { 1 => 2, 3 => 4 }
+  end
+
+  it "calls to_hash on hash subclasses" do
+    h = {}
+    h.replace(HashSpecs::ToHashHash[1 => 2])
+    h.should == { 1 => 2 }
+  end
+
+  it "transfers the compare_by_identity flag" do
+    hash_a = { a: 1 }
+    hash_b = { b: 2 }
+    hash_b.compare_by_identity
+    hash_a.should_not.compare_by_identity?
+    hash_a.replace(hash_b)
+    hash_a.should.compare_by_identity?
+
+    hash_a = { a: 1 }
+    hash_b = { b: 2 }
+    hash_a.compare_by_identity
+    hash_a.should.compare_by_identity?
+    hash_a.replace(hash_b)
+    hash_a.should_not.compare_by_identity?
+  end
+
+  it "does not transfer default values" do
+    hash_a = {}
+    hash_b = Hash.new(5)
+    hash_a.replace(hash_b)
+    hash_a.default.should == 5
+
+    hash_a = {}
+    hash_b = Hash.new { |h, k| k * 2 }
+    hash_a.replace(hash_b)
+    hash_a.default(5).should == 10
+
+    hash_a = Hash.new { |h, k| k * 5 }
+    hash_b = Hash.new(-> { raise "Should not invoke lambda" })
+    hash_a.replace(hash_b)
+    hash_a.default.should == hash_b.default
+  end
+
+  it "raises a FrozenError if called on a frozen instance that would not be modified" do
+    -> do
+      HashSpecs.frozen_hash.replace(HashSpecs.frozen_hash)
+    end.should raise_error(FrozenError)
+  end
+
+  it "raises a FrozenError if called on a frozen instance that is modified" do
+    -> do
+      HashSpecs.frozen_hash.replace(HashSpecs.empty_frozen_hash)
+    end.should raise_error(FrozenError)
+  end
 end
diff --git a/spec/ruby/core/hash/shared/replace.rb b/spec/ruby/core/hash/shared/replace.rb
deleted file mode 100644
index bea64384bb..0000000000
--- a/spec/ruby/core/hash/shared/replace.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-describe :hash_replace, shared: true do
-  it "replaces the contents of self with other" do
-    h = { a: 1, b: 2 }
-    h.send(@method, c: -1, d: -2).should equal(h)
-    h.should == { c: -1, d: -2 }
-  end
-
-  it "tries to convert the passed argument to a hash using #to_hash" do
-    obj = mock('{1=>2,3=>4}')
-    obj.should_receive(:to_hash).and_return({ 1 => 2, 3 => 4 })
-
-    h = {}
-    h.send(@method, obj)
-    h.should == { 1 => 2, 3 => 4 }
-  end
-
-  it "calls to_hash on hash subclasses" do
-    h = {}
-    h.send(@method, HashSpecs::ToHashHash[1 => 2])
-    h.should == { 1 => 2 }
-  end
-
-  it "does not transfer default values" do
-    hash_a = {}
-    hash_b = Hash.new(5)
-    hash_a.send(@method, hash_b)
-    hash_a.default.should == 5
-
-    hash_a = {}
-    hash_b = Hash.new { |h, k| k * 2 }
-    hash_a.send(@method, hash_b)
-    hash_a.default(5).should == 10
-
-    hash_a = Hash.new { |h, k| k * 5 }
-    hash_b = Hash.new(-> { raise "Should not invoke lambda" })
-    hash_a.send(@method, hash_b)
-    hash_a.default.should == hash_b.default
-  end
-
-  it "raises a FrozenError if called on a frozen instance that would not be modified" do
-    -> do
-      HashSpecs.frozen_hash.send(@method, HashSpecs.frozen_hash)
-    end.should raise_error(FrozenError)
-  end
-
-  it "raises a FrozenError if called on a frozen instance that is modified" do
-    -> do
-      HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
-    end.should raise_error(FrozenError)
-  end
-end
diff --git a/spec/ruby/core/hash/to_h_spec.rb b/spec/ruby/core/hash/to_h_spec.rb
index 75ebce68b1..e17ca7e671 100644
--- a/spec/ruby/core/hash/to_h_spec.rb
+++ b/spec/ruby/core/hash/to_h_spec.rb
@@ -37,6 +37,16 @@ describe "Hash#to_h" do
       { a: 1, b: 2 }.to_h { |k, v| [k.to_s, v*v]}.should == { "a" => 1, "b" => 4 }
     end
 
+    it "passes to a block each pair's key and value as separate arguments" do
+      ScratchPad.record []
+      { a: 1, b: 2 }.to_h { |k, v| ScratchPad << [k, v]; [k, v] }
+      ScratchPad.recorded.sort.should == [[:a, 1], [:b, 2]]
+
+      ScratchPad.record []
+      { a: 1, b: 2 }.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [[:a, 1], [:b, 2]]
+    end
+
     it "raises ArgumentError if block returns longer or shorter array" do
       -> do
         { a: 1, b: 2 }.to_h { |k, v| [k.to_s, v*v, 1] }
diff --git a/spec/ruby/core/integer/chr_spec.rb b/spec/ruby/core/integer/chr_spec.rb
index 8fe20ff812..39cafe2874 100644
--- a/spec/ruby/core/integer/chr_spec.rb
+++ b/spec/ruby/core/integer/chr_spec.rb
@@ -10,12 +10,12 @@ describe "Integer#chr without argument" do
   end
 
   it "raises a RangeError is self is less than 0" do
-    -> { -1.chr }.should raise_error(RangeError)
-    -> { (-bignum_value).chr }.should raise_error(RangeError)
+    -> { -1.chr }.should raise_error(RangeError, /-1 out of char range/)
+    -> { (-bignum_value).chr }.should raise_error(RangeError, /bignum out of char range/)
   end
 
   it "raises a RangeError if self is too large" do
-    -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError)
+    -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError, /2206368128 out of char range/)
   end
 
   describe "when Encoding.default_internal is nil" do
@@ -48,8 +48,8 @@ describe "Integer#chr without argument" do
     end
 
     it "raises a RangeError is self is greater than 255" do
-      -> { 256.chr }.should raise_error(RangeError)
-      -> { bignum_value.chr }.should raise_error(RangeError)
+      -> { 256.chr }.should raise_error(RangeError, /256 out of char range/)
+      -> { bignum_value.chr }.should raise_error(RangeError, /bignum out of char range/)
     end
   end
 
@@ -137,7 +137,7 @@ describe "Integer#chr without argument" do
           [620,    "TIS-620"]
         ].each do |integer, encoding_name|
           Encoding.default_internal = Encoding.find(encoding_name)
-          -> { integer.chr }.should raise_error(RangeError)
+          -> { integer.chr }.should raise_error(RangeError, /(invalid codepoint|out of char range)/)
         end
       end
     end
@@ -165,12 +165,12 @@ describe "Integer#chr with an encoding argument" do
 
   # http://redmine.ruby-lang.org/issues/4869
   it "raises a RangeError is self is less than 0" do
-    -> { -1.chr(Encoding::UTF_8) }.should raise_error(RangeError)
-    -> { (-bignum_value).chr(Encoding::EUC_JP) }.should raise_error(RangeError)
+    -> { -1.chr(Encoding::UTF_8) }.should raise_error(RangeError, /-1 out of char range/)
+    -> { (-bignum_value).chr(Encoding::EUC_JP) }.should raise_error(RangeError, /bignum out of char range/)
   end
 
   it "raises a RangeError if self is too large" do
-    -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError)
+    -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError, /2206368128 out of char range/)
   end
 
   it "returns a String with the specified encoding" do
diff --git a/spec/ruby/core/io/autoclose_spec.rb b/spec/ruby/core/io/autoclose_spec.rb
new file mode 100644
index 0000000000..715ada7c93
--- /dev/null
+++ b/spec/ruby/core/io/autoclose_spec.rb
@@ -0,0 +1,77 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
+
+describe "IO#autoclose?" do
+  before :each do
+    @io = IOSpecs.io_fixture "lines.txt"
+  end
+
+  after :each do
+    @io.autoclose = true unless @io.closed?
+    @io.close unless @io.closed?
+  end
+
+  it "is set to true by default" do
+    @io.should.autoclose?
+  end
+
+  it "cannot be queried on a closed IO object" do
+    @io.close
+    -> { @io.autoclose? }.should raise_error(IOError, /closed stream/)
+  end
+end
+
+describe "IO#autoclose=" do
+  before :each do
+    @io = IOSpecs.io_fixture "lines.txt"
+  end
+
+  after :each do
+    @io.autoclose = true unless @io.closed?
+    @io.close unless @io.closed?
+  end
+
+  it "can be set to true" do
+    @io.autoclose = false
+    @io.autoclose = true
+    @io.should.autoclose?
+  end
+
+  it "can be set to false" do
+    @io.autoclose = true
+    @io.autoclose = false
+    @io.should_not.autoclose?
+  end
+
+  it "can be set to any truthy value" do
+    @io.autoclose = false
+    @io.autoclose = 42
+    @io.should.autoclose?
+
+    @io.autoclose = false
+    @io.autoclose = Object.new
+    @io.should.autoclose?
+  end
+
+  it "can be set to any falsy value" do
+    @io.autoclose = true
+    @io.autoclose = nil
+    @io.should_not.autoclose?
+  end
+
+  it "can be set multiple times" do
+    @io.autoclose = true
+    @io.should.autoclose?
+
+    @io.autoclose = false
+    @io.should_not.autoclose?
+
+    @io.autoclose = true
+    @io.should.autoclose?
+  end
+
+  it "cannot be set on a closed IO object" do
+    @io.close
+    -> { @io.autoclose = false }.should raise_error(IOError, /closed stream/)
+  end
+end
diff --git a/spec/ruby/core/kernel/caller_spec.rb b/spec/ruby/core/kernel/caller_spec.rb
index c3d63ccb00..33c7929a31 100644
--- a/spec/ruby/core/kernel/caller_spec.rb
+++ b/spec/ruby/core/kernel/caller_spec.rb
@@ -43,16 +43,44 @@ describe 'Kernel#caller' do
     lines[1].should =~ /\A#{path}:2:in [`']block in <main>'\n\z/
   end
 
+  it "can be called with a range" do
+    locations1 = caller(0)
+    locations2 = caller(2..4)
+    locations1[2..4].should == locations2
+  end
+
   it "works with endless ranges" do
     locations1 = KernelSpecs::CallerTest.locations(0)
     locations2 = KernelSpecs::CallerTest.locations(eval("(2..)"))
-    locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
+    locations2.should == locations1[2..-1]
   end
 
   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..)")]
+    locations2[eval("(2..)")].should == locations1[(..5)][eval("(2..)")]
+  end
+
+  it "can be called with a range whose end is negative" do
+    locations1 = caller(0)
+    locations2 = caller(2..-1)
+    locations3 = caller(2..-2)
+    locations1[2..-1].should == locations2
+    locations1[2..-2].should == locations3
+  end
+
+  it "must return nil if omitting more locations than available" do
+    caller(100).should == nil
+    caller(100..-1).should == nil
+  end
+
+  it "must return [] if omitting exactly the number of locations available" do
+    omit = caller(0).length
+    caller(omit).should == []
+  end
+
+  it "must return the same locations when called with 1..-1 and when called with no arguments" do
+    caller.should == caller(1..-1)
   end
 
   guard -> { Kernel.instance_method(:tap).source_location } do
diff --git a/spec/ruby/core/kernel/sleep_spec.rb b/spec/ruby/core/kernel/sleep_spec.rb
index 0570629723..d35e313006 100644
--- a/spec/ruby/core/kernel/sleep_spec.rb
+++ b/spec/ruby/core/kernel/sleep_spec.rb
@@ -21,7 +21,7 @@ describe "Kernel#sleep" do
     sleep(Rational(1, 999)).should >= 0
   end
 
-  it "accepts any Object that reponds to divmod" do
+  it "accepts any Object that responds to divmod" do
     o = Object.new
     def o.divmod(*); [0, 0.001]; end
     sleep(o).should >= 0
diff --git a/spec/ruby/core/matchdata/element_reference_spec.rb b/spec/ruby/core/matchdata/element_reference_spec.rb
index 806db2d7b5..0924be0aae 100644
--- a/spec/ruby/core/matchdata/element_reference_spec.rb
+++ b/spec/ruby/core/matchdata/element_reference_spec.rb
@@ -20,6 +20,11 @@ describe "MatchData#[]" do
     # negative index is larger than the number of match values
     /(.)(.)(\d+)(\d)/.match("THX1138.")[-30, 2].should == nil
 
+    # positive index larger than number of match values
+    /(.)(.)(\d+)(\d)/.match("THX1138.")[5, 2].should == []
+    /(.)(.)(\d+)(\d)/.match("THX1138.")[6, 2].should == nil
+    /(.)(.)(\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|
 
diff --git a/spec/ruby/core/regexp/shared/new.rb b/spec/ruby/core/regexp/shared/new.rb
index 7c3fabf612..7052bcab63 100644
--- a/spec/ruby/core/regexp/shared/new.rb
+++ b/spec/ruby/core/regexp/shared/new.rb
@@ -56,7 +56,7 @@ describe :regexp_new_string, shared: true do
   end
 
   it "raises a RegexpError when passed an incorrect regexp" do
-    -> { Regexp.send(@method, "^[$", 0) }.should raise_error(RegexpError)
+    -> { Regexp.send(@method, "^[$", 0) }.should raise_error(RegexpError, Regexp.new(Regexp.escape("premature end of char-class: /^[$/")))
   end
 
   it "does not set Regexp options if only given one argument" do
@@ -261,7 +261,7 @@ describe :regexp_new_string, shared: true do
 
   describe "with escaped characters" do
     it "raises a Regexp error if there is a trailing backslash" do
-      -> { Regexp.send(@method, "\\") }.should raise_error(RegexpError)
+      -> { Regexp.send(@method, "\\") }.should raise_error(RegexpError, Regexp.new(Regexp.escape("too short escape sequence: /\\/")))
     end
 
     it "does not raise a Regexp error if there is an escaped trailing backslash" do
@@ -293,7 +293,7 @@ describe :regexp_new_string, shared: true do
     end
 
     it "raises a RegexpError if \\x is not followed by any hexadecimal digits" do
-      -> { Regexp.send(@method, "\\" + "xn") }.should raise_error(RegexpError)
+      -> { Regexp.send(@method, "\\" + "xn") }.should raise_error(RegexpError, Regexp.new(Regexp.escape("invalid hex escape: /\\xn/")))
     end
 
     it "accepts an escaped string interpolation" do
@@ -453,15 +453,15 @@ describe :regexp_new_string, shared: true do
     end
 
     it "raises a RegexpError if less than four digits are given for \\uHHHH" do
-      -> { Regexp.send(@method, "\\" + "u304") }.should raise_error(RegexpError)
+      -> { Regexp.send(@method, "\\" + "u304") }.should raise_error(RegexpError, Regexp.new(Regexp.escape("invalid Unicode escape: /\\u304/")))
     end
 
     it "raises a RegexpError if the \\u{} escape is empty" do
-      -> { Regexp.send(@method, "\\" + "u{}") }.should raise_error(RegexpError)
+      -> { Regexp.send(@method, "\\" + "u{}") }.should raise_error(RegexpError, Regexp.new(Regexp.escape("invalid Unicode list: /\\u{}/")))
     end
 
     it "raises a RegexpError if more than six hexadecimal digits are given" do
-      -> { Regexp.send(@method, "\\" + "u{0ffffff}") }.should raise_error(RegexpError)
+      -> { Regexp.send(@method, "\\" + "u{0ffffff}") }.should raise_error(RegexpError, Regexp.new(Regexp.escape("invalid Unicode range: /\\u{0ffffff}/")))
     end
 
     it "returns a Regexp with US-ASCII encoding if only 7-bit ASCII characters are present regardless of the input String's encoding" do
diff --git a/spec/ruby/core/string/encode_spec.rb b/spec/ruby/core/string/encode_spec.rb
index 97dd753b62..cd449498a3 100644
--- a/spec/ruby/core/string/encode_spec.rb
+++ b/spec/ruby/core/string/encode_spec.rb
@@ -61,10 +61,22 @@ describe "String#encode" do
       str.encode(invalid: :replace).should_not equal(str)
     end
 
-    it "normalizes newlines" do
-      "\r\nfoo".encode(universal_newline: true).should == "\nfoo"
+    it "normalizes newlines with cr_newline option" do
+      "\r\nfoo".encode(cr_newline: true).should == "\r\rfoo"
+      "\rfoo".encode(cr_newline: true).should == "\rfoo"
+      "\nfoo".encode(cr_newline: true).should == "\rfoo"
+    end
 
+    it "normalizes newlines with crlf_newline option" do
+      "\r\nfoo".encode(crlf_newline: true).should == "\r\r\nfoo"
+      "\rfoo".encode(crlf_newline: true).should == "\rfoo"
+      "\nfoo".encode(crlf_newline: true).should == "\r\nfoo"
+    end
+
+    it "normalizes newlines with universal_newline option" do
+      "\r\nfoo".encode(universal_newline: true).should == "\nfoo"
       "\rfoo".encode(universal_newline: true).should == "\nfoo"
+      "\nfoo".encode(universal_newline: true).should == "\nfoo"
     end
 
     it "replaces invalid encoding in source with default replacement" do
diff --git a/spec/ruby/core/string/shared/encode.rb b/spec/ruby/core/string/shared/encode.rb
index 3776e0d709..9466308886 100644
--- a/spec/ruby/core/string/shared/encode.rb
+++ b/spec/ruby/core/string/shared/encode.rb
@@ -194,6 +194,190 @@ describe :string_encode, shared: true do
     end
   end
 
+  describe "given the fallback option" do
+    context "given a hash" do
+      it "looks up the replacement value from the hash" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: { "\ufffd" => "bar" })
+        encoded.should == "Bbar"
+      end
+
+      it "calls to_str on the returned value" do
+        obj = Object.new
+        obj.should_receive(:to_str).and_return("bar")
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: { "\ufffd" => obj })
+        encoded.should == "Bbar"
+      end
+
+      it "does not call to_s on the returned value" do
+        obj = Object.new
+        obj.should_not_receive(:to_s)
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: { "\ufffd" => obj })
+        }.should raise_error(TypeError, "no implicit conversion of Object into String")
+      end
+
+      it "raises an error if the key is not present in the hash" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: { "foo" => "bar" })
+        }.should raise_error(Encoding::UndefinedConversionError, "U+FFFD from UTF-8 to US-ASCII")
+      end
+
+      it "raises an error if the value is itself invalid" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: { "\ufffd" => "\uffee" })
+        }.should raise_error(ArgumentError, "too big fallback string")
+      end
+
+      it "uses the hash's default value if set" do
+        hash = {}
+        hash.default = "bar"
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: hash)
+        encoded.should == "Bbar"
+      end
+
+      it "uses the result of calling default_proc if set" do
+        hash = {}
+        hash.default_proc = -> _, _ { "bar" }
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: hash)
+        encoded.should == "Bbar"
+      end
+    end
+
+    context "given an object inheriting from Hash" do
+      before do
+        klass = Class.new(Hash)
+        @hash_like = klass.new
+        @hash_like["\ufffd"] = "bar"
+      end
+
+      it "looks up the replacement value from the object" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: @hash_like)
+        encoded.should == "Bbar"
+      end
+    end
+
+    context "given an object responding to []" do
+      before do
+        klass = Class.new do
+          def [](c) = c.bytes.inspect
+        end
+        @hash_like = klass.new
+      end
+
+      it "calls [] on the object, passing the invalid character" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: @hash_like)
+        encoded.should == "B[239, 191, 189]"
+      end
+    end
+
+    context "given an object not responding to []" do
+      before do
+        @non_hash_like = Object.new
+      end
+
+      it "raises an error" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: @non_hash_like)
+        }.should raise_error(Encoding::UndefinedConversionError, "U+FFFD from UTF-8 to US-ASCII")
+      end
+    end
+
+    context "given a proc" do
+      it "calls the proc to get the replacement value, passing in the invalid character" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: proc { |c| c.bytes.inspect })
+        encoded.should == "B[239, 191, 189]"
+      end
+
+      it "calls to_str on the returned value" do
+        obj = Object.new
+        obj.should_receive(:to_str).and_return("bar")
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: proc { |c| obj })
+        encoded.should == "Bbar"
+      end
+
+      it "does not call to_s on the returned value" do
+        obj = Object.new
+        obj.should_not_receive(:to_s)
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: proc { |c| obj })
+        }.should raise_error(TypeError, "no implicit conversion of Object into String")
+      end
+
+      it "raises an error if the returned value is itself invalid" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: -> c { "\uffee" })
+        }.should raise_error(ArgumentError, "too big fallback string")
+      end
+    end
+
+    context "given a lambda" do
+      it "calls the lambda to get the replacement value, passing in the invalid character" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: -> c { c.bytes.inspect })
+        encoded.should == "B[239, 191, 189]"
+      end
+
+      it "calls to_str on the returned value" do
+        obj = Object.new
+        obj.should_receive(:to_str).and_return("bar")
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: -> c { obj })
+        encoded.should == "Bbar"
+      end
+
+      it "does not call to_s on the returned value" do
+        obj = Object.new
+        obj.should_not_receive(:to_s)
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: -> c { obj })
+        }.should raise_error(TypeError, "no implicit conversion of Object into String")
+      end
+
+      it "raises an error if the returned value is itself invalid" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: -> c { "\uffee" })
+        }.should raise_error(ArgumentError, "too big fallback string")
+      end
+    end
+
+    context "given a method" do
+      def replace(c) = c.bytes.inspect
+      def replace_bad(c) = "\uffee"
+
+      def replace_to_str(c)
+        obj = Object.new
+        obj.should_receive(:to_str).and_return("bar")
+        obj
+      end
+
+      def replace_to_s(c)
+        obj = Object.new
+        obj.should_not_receive(:to_s)
+        obj
+      end
+
+      it "calls the method to get the replacement value, passing in the invalid character" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: method(:replace))
+        encoded.should == "B[239, 191, 189]"
+      end
+
+      it "calls to_str on the returned value" do
+        encoded = "B\ufffd".encode(Encoding::US_ASCII, fallback: method(:replace_to_str))
+        encoded.should == "Bbar"
+      end
+
+      it "does not call to_s on the returned value" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: method(:replace_to_s))
+        }.should raise_error(TypeError, "no implicit conversion of Object into String")
+      end
+
+      it "raises an error if the returned value is itself invalid" do
+        -> {
+          "B\ufffd".encode(Encoding::US_ASCII, fallback: method(:replace_bad))
+        }.should raise_error(ArgumentError, "too big fallback string")
+      end
+    end
+  end
+
   describe "given the xml: :text option" do
     it "replaces all instances of '&' with '&amp;'" do
       '& and &'.send(@method, "UTF-8", xml: :text).should == '&amp; and &amp;'
diff --git a/spec/ruby/core/struct/to_h_spec.rb b/spec/ruby/core/struct/to_h_spec.rb
index bfb0af07ba..861ce3f49d 100644
--- a/spec/ruby/core/struct/to_h_spec.rb
+++ b/spec/ruby/core/struct/to_h_spec.rb
@@ -21,6 +21,18 @@ describe "Struct#to_h" do
       h.should == { "make" => "ford", "model" => "ranger", "year" => "" }
     end
 
+    it "passes to a block each pair's key and value as separate arguments" do
+      s = StructClasses::Ruby.new('3.2.4', 'macos')
+
+      ScratchPad.record []
+      s.to_h { |k, v| ScratchPad << [k, v]; [k, v] }
+      ScratchPad.recorded.sort.should == [[:platform, 'macos'], [:version, '3.2.4']]
+
+      ScratchPad.record []
+      s.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [[:platform, 'macos'], [:version, '3.2.4']]
+    end
+
     it "raises ArgumentError if block returns longer or shorter array" do
       -> do
         StructClasses::Car.new.to_h { |k, v| [k.to_s, "#{v}".downcase, 1] }
diff --git a/spec/ruby/core/thread/thread_variable_get_spec.rb b/spec/ruby/core/thread/thread_variable_get_spec.rb
index 0ad19bfd88..67017771fd 100644
--- a/spec/ruby/core/thread/thread_variable_get_spec.rb
+++ b/spec/ruby/core/thread/thread_variable_get_spec.rb
@@ -14,12 +14,40 @@ describe "Thread#thread_variable_get" do
   end
 
   it "returns the value previously set by #thread_variable_set" do
-    @t.thread_variable_set :a, 49
+    @t.thread_variable_set(:a, 49)
     @t.thread_variable_get(:a).should == 49
   end
 
   it "returns a value private to self" do
-    @t.thread_variable_set :thread_variable_get_spec, 82
+    @t.thread_variable_set(:thread_variable_get_spec, 82)
     Thread.current.thread_variable_get(:thread_variable_get_spec).should be_nil
   end
+
+  it "accepts String and Symbol keys interchangeably" do
+    @t.thread_variable_set("a", 49)
+    @t.thread_variable_get("a").should == 49
+    @t.thread_variable_get(:a).should == 49
+  end
+
+  it "converts a key that is neither String nor Symbol with #to_str" do
+    key = mock('key')
+    key.should_receive(:to_str).and_return('a')
+    @t.thread_variable_set(:a, 49)
+    @t.thread_variable_get(key).should == 49
+  end
+
+  it "does not raise FrozenError if the thread is frozen" do
+    @t.freeze
+    @t.thread_variable_get(:a).should be_nil
+  end
+
+  it "does not raise a TypeError if the key is neither Symbol nor String, nor responds to #to_str" do
+    @t.thread_variable_get(123).should be_nil
+  end
+
+  it "does not try to convert the key with #to_sym" do
+    key = mock('key')
+    key.should_not_receive(:to_sym)
+    @t.thread_variable_get(key).should be_nil
+  end
 end
diff --git a/spec/ruby/core/thread/thread_variable_set_spec.rb b/spec/ruby/core/thread/thread_variable_set_spec.rb
index 1338c306c7..c262a6614e 100644
--- a/spec/ruby/core/thread/thread_variable_set_spec.rb
+++ b/spec/ruby/core/thread/thread_variable_set_spec.rb
@@ -10,17 +10,53 @@ describe "Thread#thread_variable_set" do
   end
 
   it "returns the value set" do
-    (@t.thread_variable_set :a, 2).should == 2
+    @t.thread_variable_set(:a, 2).should == 2
   end
 
   it "sets a value that will be returned by #thread_variable_get" do
-    @t.thread_variable_set :a, 49
+    @t.thread_variable_set(:a, 49)
     @t.thread_variable_get(:a).should == 49
   end
 
   it "sets a value private to self" do
-    @t.thread_variable_set :thread_variable_get_spec, 82
+    @t.thread_variable_set(:thread_variable_get_spec, 82)
     @t.thread_variable_get(:thread_variable_get_spec).should == 82
     Thread.current.thread_variable_get(:thread_variable_get_spec).should be_nil
   end
+
+  it "accepts String and Symbol keys interchangeably" do
+    @t.thread_variable_set('a', 49)
+    @t.thread_variable_get('a').should == 49
+
+    @t.thread_variable_set(:a, 50)
+    @t.thread_variable_get('a').should == 50
+  end
+
+  it "converts a key that is neither String nor Symbol with #to_str" do
+    key = mock('key')
+    key.should_receive(:to_str).and_return('a')
+    @t.thread_variable_set(key, 49)
+    @t.thread_variable_get(:a).should == 49
+  end
+
+  it "removes a key if the value is nil" do
+    @t.thread_variable_set(:a, 52)
+    @t.thread_variable_set(:a, nil)
+    @t.thread_variable?(:a).should be_false
+  end
+
+  it "raises a FrozenError if the thread is frozen" do
+    @t.freeze
+    -> { @t.thread_variable_set(:a, 1) }.should raise_error(FrozenError, "can't modify frozen thread locals")
+  end
+
+  it "raises a TypeError if the key is neither Symbol nor String, nor responds to #to_str" do
+    -> { @t.thread_variable_set(123, 1) }.should raise_error(TypeError, '123 is not a symbol')
+  end
+
+  it "does not try to convert the key with #to_sym" do
+    key = mock('key')
+    key.should_not_receive(:to_sym)
+    -> { @t.thread_variable_set(key, 42) }.should raise_error(TypeError, "#{key.inspect} is not a symbol")
+  end
 end
diff --git a/spec/ruby/core/thread/thread_variable_spec.rb b/spec/ruby/core/thread/thread_variable_spec.rb
index 6bd1950c04..d64e6ec63d 100644
--- a/spec/ruby/core/thread/thread_variable_spec.rb
+++ b/spec/ruby/core/thread/thread_variable_spec.rb
@@ -10,12 +10,44 @@ describe "Thread#thread_variable?" do
   end
 
   it "returns false if the thread variables do not contain 'key'" do
-    @t.thread_variable_set :a, 2
+    @t.thread_variable_set(:a, 2)
     @t.thread_variable?(:b).should be_false
   end
 
   it "returns true if the thread variables contain 'key'" do
-    @t.thread_variable_set :a, 2
+    @t.thread_variable_set(:a, 2)
     @t.thread_variable?(:a).should be_true
   end
+
+  it "accepts String and Symbol keys interchangeably" do
+    @t.thread_variable?('a').should be_false
+    @t.thread_variable?(:a).should be_false
+
+    @t.thread_variable_set(:a, 49)
+
+    @t.thread_variable?('a').should be_true
+    @t.thread_variable?(:a).should be_true
+  end
+
+  it "converts a key that is neither String nor Symbol with #to_str" do
+    key = mock('key')
+    key.should_receive(:to_str).and_return('a')
+    @t.thread_variable_set(:a, 49)
+    @t.thread_variable?(key).should be_true
+  end
+
+  it "does not raise FrozenError if the thread is frozen" do
+    @t.freeze
+    @t.thread_variable?(:a).should be_false
+  end
+
+  it "does not raise a TypeError if the key is neither Symbol nor String, nor responds to #to_str" do
+    @t.thread_variable?(123).should be_false
+  end
+
+  it "does not try to convert the key with #to_sym" do
+    key = mock('key')
+    key.should_not_receive(:to_sym)
+    @t.thread_variable?(key).should be_false
+  end
 end
diff --git a/spec/ruby/core/thread/thread_variables_spec.rb b/spec/ruby/core/thread/thread_variables_spec.rb
index 1bd68b17f1..51ceef3376 100644
--- a/spec/ruby/core/thread/thread_variables_spec.rb
+++ b/spec/ruby/core/thread/thread_variables_spec.rb
@@ -10,15 +10,15 @@ describe "Thread#thread_variables" do
   end
 
   it "returns the keys of all the values set" do
-    @t.thread_variable_set :a, 2
-    @t.thread_variable_set :b, 4
-    @t.thread_variable_set :c, 6
+    @t.thread_variable_set(:a, 2)
+    @t.thread_variable_set(:b, 4)
+    @t.thread_variable_set(:c, 6)
     @t.thread_variables.sort.should == [:a, :b, :c]
   end
 
-  it "sets a value private to self" do
-    @t.thread_variable_set :a, 82
-    @t.thread_variable_set :b, 82
+  it "returns the keys private to self" do
+    @t.thread_variable_set(:a, 82)
+    @t.thread_variable_set(:b, 82)
     Thread.current.thread_variables.should_not include(:a, :b)
   end
 
@@ -26,4 +26,14 @@ describe "Thread#thread_variables" do
     Thread.current.thread_variables.should == []
     @t.thread_variables.should == []
   end
+
+  it "returns keys as Symbols" do
+    key = mock('key')
+    key.should_receive(:to_str).and_return('a')
+
+    @t.thread_variable_set(key, 49)
+    @t.thread_variable_set('b', 50)
+    @t.thread_variable_set(:c, 51)
+    @t.thread_variables.sort.should == [:a, :b, :c]
+  end
 end
diff --git a/spec/ruby/core/time/yday_spec.rb b/spec/ruby/core/time/yday_spec.rb
index 6ea5ff8f1b..e920c2e28d 100644
--- a/spec/ruby/core/time/yday_spec.rb
+++ b/spec/ruby/core/time/yday_spec.rb
@@ -1,4 +1,5 @@
 require_relative '../../spec_helper'
+require_relative '../../shared/time/yday'
 
 describe "Time#yday" do
   it "returns an integer representing the day of the year, 1..366" do
@@ -7,15 +8,5 @@ describe "Time#yday" do
     end
   end
 
-  it 'returns the correct value for each day of each month' do
-    mdays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-    yday = 1
-    mdays.each_with_index do |days, month|
-      days.times do |day|
-        Time.new(2014, month+1, day+1).yday.should == yday
-        yday += 1
-      end
-    end
-  end
+  it_behaves_like :time_yday, -> year, month, day { Time.new(year, month, day).yday }
 end