Update to ruby/spec@875a09e

author: Benoit Daloze <[email protected]> 2019-07-27 12:40:09 +0200
committer: Benoit Daloze <[email protected]> 2019-07-27 12:40:09 +0200
commit: 5c276e1cc91c5ab2a41fbf7827af2fed914a2bc0 (patch)
tree: 05b5c68c8b2a00224d4646ea3b26ce3877efaadd /spec/ruby/core/string/shared
parent: a06301b103371b0b7da8eaca26ba744961769f99 (diff)
7 files changed, 57 insertions, 57 deletions
diff --git a/spec/ruby/core/string/shared/codepoints.rb b/spec/ruby/core/string/shared/codepoints.rb
index 84a0e3ae39..e94a57f48e 100644
--- a/spec/ruby/core/string/shared/codepoints.rb
+++ b/spec/ruby/core/string/shared/codepoints.rb
@@ -9,7 +9,7 @@ describe :string_codepoints, shared: true do
   it "raises an ArgumentError when self has an invalid encoding and a method is called on the returned Enumerator" do
     s = "\xDF".force_encoding(Encoding::UTF_8)
     s.valid_encoding?.should be_false
-    lambda { s.send(@method).to_a }.should raise_error(ArgumentError)
+    -> { s.send(@method).to_a }.should raise_error(ArgumentError)
   end
 
   it "yields each codepoint to the block if one is given" do
@@ -23,7 +23,7 @@ describe :string_codepoints, shared: true do
   it "raises an ArgumentError if self's encoding is invalid and a block is given" do
     s = "\xDF".force_encoding(Encoding::UTF_8)
     s.valid_encoding?.should be_false
-    lambda { s.send(@method) { } }.should raise_error(ArgumentError)
+    -> { s.send(@method) { } }.should raise_error(ArgumentError)
   end
 
   it "yields codepoints as Fixnums" do
diff --git a/spec/ruby/core/string/shared/concat.rb b/spec/ruby/core/string/shared/concat.rb
index 0a87410f2f..53a8bc23fb 100644
--- a/spec/ruby/core/string/shared/concat.rb
+++ b/spec/ruby/core/string/shared/concat.rb
@@ -13,16 +13,16 @@ describe :string_concat, shared: true do
   end
 
   it "raises a TypeError if the given argument can't be converted to a String" do
-    lambda { 'hello '.send(@method, [])        }.should raise_error(TypeError)
-    lambda { 'hello '.send(@method, mock('x')) }.should raise_error(TypeError)
+    -> { 'hello '.send(@method, [])        }.should raise_error(TypeError)
+    -> { 'hello '.send(@method, mock('x')) }.should raise_error(TypeError)
   end
 
   it "raises a #{frozen_error_class} when self is frozen" do
     a = "hello"
     a.freeze
 
-    lambda { a.send(@method, "")     }.should raise_error(frozen_error_class)
-    lambda { a.send(@method, "test") }.should raise_error(frozen_error_class)
+    -> { a.send(@method, "")     }.should raise_error(frozen_error_class)
+    -> { a.send(@method, "test") }.should raise_error(frozen_error_class)
   end
 
   it "returns a String when given a subclass instance" do
@@ -71,28 +71,28 @@ describe :string_concat, shared: true do
     end
 
     it "raises RangeError if the argument is an invalid codepoint for self's encoding" do
-      lambda { "".encode(Encoding::US_ASCII).send(@method, 256) }.should raise_error(RangeError)
-      lambda { "".encode(Encoding::EUC_JP).send(@method, 0x81)  }.should raise_error(RangeError)
+      -> { "".encode(Encoding::US_ASCII).send(@method, 256) }.should raise_error(RangeError)
+      -> { "".encode(Encoding::EUC_JP).send(@method, 0x81)  }.should raise_error(RangeError)
     end
 
     it "raises RangeError if the argument is negative" do
-      lambda { "".send(@method, -200)          }.should raise_error(RangeError)
-      lambda { "".send(@method, -bignum_value) }.should raise_error(RangeError)
+      -> { "".send(@method, -200)          }.should raise_error(RangeError)
+      -> { "".send(@method, -bignum_value) }.should raise_error(RangeError)
     end
 
     it "doesn't call to_int on its argument" do
       x = mock('x')
       x.should_not_receive(:to_int)
 
-      lambda { "".send(@method, x) }.should raise_error(TypeError)
+      -> { "".send(@method, x) }.should raise_error(TypeError)
     end
 
     it "raises a #{frozen_error_class} when self is frozen" do
       a = "hello"
       a.freeze
 
-      lambda { a.send(@method, 0)  }.should raise_error(frozen_error_class)
-      lambda { a.send(@method, 33) }.should raise_error(frozen_error_class)
+      -> { a.send(@method, 0)  }.should raise_error(frozen_error_class)
+      -> { a.send(@method, 33) }.should raise_error(frozen_error_class)
     end
   end
 end
@@ -112,7 +112,7 @@ describe :string_concat_encoding, shared: true do
     end
 
     it "raises Encoding::CompatibilityError if neither are empty" do
-      lambda { "x".encode("UTF-16LE").send(@method, "y".encode("UTF-8")) }.should raise_error(Encoding::CompatibilityError)
+      -> { "x".encode("UTF-16LE").send(@method, "y".encode("UTF-8")) }.should raise_error(Encoding::CompatibilityError)
     end
   end
 
@@ -130,7 +130,7 @@ describe :string_concat_encoding, shared: true do
     end
 
     it "raises Encoding::CompatibilityError if neither are empty" do
-      lambda { "x".encode("UTF-8").send(@method, "y".encode("UTF-16LE")) }.should raise_error(Encoding::CompatibilityError)
+      -> { "x".encode("UTF-8").send(@method, "y".encode("UTF-16LE")) }.should raise_error(Encoding::CompatibilityError)
     end
   end
 
@@ -148,7 +148,7 @@ describe :string_concat_encoding, shared: true do
     end
 
     it "raises Encoding::CompatibilityError if neither are ASCII-only" do
-      lambda { "\u00E9".encode("UTF-8").send(@method, "\u00E9".encode("ISO-8859-1")) }.should raise_error(Encoding::CompatibilityError)
+      -> { "\u00E9".encode("UTF-8").send(@method, "\u00E9".encode("ISO-8859-1")) }.should raise_error(Encoding::CompatibilityError)
     end
   end
 
diff --git a/spec/ruby/core/string/shared/each_line.rb b/spec/ruby/core/string/shared/each_line.rb
index 86c966e50b..241a90eee3 100644
--- a/spec/ruby/core/string/shared/each_line.rb
+++ b/spec/ruby/core/string/shared/each_line.rb
@@ -133,8 +133,8 @@ describe :string_each_line, shared: true do
   end
 
   it "raises a TypeError when the separator can't be converted to a string" do
-    lambda { "hello world".send(@method, false) {}     }.should raise_error(TypeError)
-    lambda { "hello world".send(@method, mock('x')) {} }.should raise_error(TypeError)
+    -> { "hello world".send(@method, false) {}     }.should raise_error(TypeError)
+    -> { "hello world".send(@method, mock('x')) {} }.should raise_error(TypeError)
   end
 
   it "accepts a string separator" do
@@ -142,7 +142,7 @@ describe :string_each_line, shared: true do
   end
 
   it "raises a TypeError when the separator is a symbol" do
-    lambda { "hello world".send(@method, :o).to_a }.should raise_error(TypeError)
+    -> { "hello world".send(@method, :o).to_a }.should raise_error(TypeError)
   end
 
   context "when `chomp` keyword argument is passed" do
diff --git a/spec/ruby/core/string/shared/encode.rb b/spec/ruby/core/string/shared/encode.rb
index d13db1945e..b5a8bf9b72 100644
--- a/spec/ruby/core/string/shared/encode.rb
+++ b/spec/ruby/core/string/shared/encode.rb
@@ -8,7 +8,7 @@ describe :string_encode, shared: true do
     end
 
     it "transcodes a 7-bit String despite no generic converting being available" do
-      lambda do
+      -> do
         Encoding::Converter.new Encoding::Emacs_Mule, Encoding::BINARY
       end.should raise_error(Encoding::ConverterNotFoundError)
 
@@ -21,7 +21,7 @@ describe :string_encode, shared: true do
     it "raises an Encoding::ConverterNotFoundError when no conversion is possible" do
       Encoding.default_internal = Encoding::Emacs_Mule
       str = [0x80].pack('C').force_encoding Encoding::BINARY
-      lambda { str.send(@method) }.should raise_error(Encoding::ConverterNotFoundError)
+      -> { str.send(@method) }.should raise_error(Encoding::ConverterNotFoundError)
     end
   end
 
@@ -51,7 +51,7 @@ describe :string_encode, shared: true do
     end
 
     it "transcodes a 7-bit String despite no generic converting being available" do
-      lambda do
+      -> do
         Encoding::Converter.new Encoding::Emacs_Mule, Encoding::BINARY
       end.should raise_error(Encoding::ConverterNotFoundError)
 
@@ -61,13 +61,13 @@ describe :string_encode, shared: true do
 
     it "raises an Encoding::ConverterNotFoundError when no conversion is possible" do
       str = [0x80].pack('C').force_encoding Encoding::BINARY
-      lambda do
+      -> do
         str.send(@method, Encoding::Emacs_Mule)
       end.should raise_error(Encoding::ConverterNotFoundError)
     end
 
     it "raises an Encoding::ConverterNotFoundError for an invalid encoding" do
-      lambda do
+      -> do
         "abc".send(@method, "xyz")
       end.should raise_error(Encoding::ConverterNotFoundError)
     end
@@ -96,7 +96,7 @@ describe :string_encode, shared: true do
     it "raises an Encoding::ConverterNotFoundError when no conversion is possible despite 'invalid: :replace, undef: :replace'" do
       Encoding.default_internal = Encoding::Emacs_Mule
       str = [0x80].pack('C').force_encoding Encoding::BINARY
-      lambda do
+      -> do
         str.send(@method, invalid: :replace, undef: :replace)
       end.should raise_error(Encoding::ConverterNotFoundError)
     end
@@ -242,6 +242,6 @@ describe :string_encode, shared: true do
   end
 
   it "raises ArgumentError if the value of the :xml option is not :text or :attr" do
-    lambda { ''.send(@method, "UTF-8", xml: :other) }.should raise_error(ArgumentError)
+    -> { ''.send(@method, "UTF-8", xml: :other) }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/string/shared/replace.rb b/spec/ruby/core/string/shared/replace.rb
index a583b88b5a..f13afb3f95 100644
--- a/spec/ruby/core/string/shared/replace.rb
+++ b/spec/ruby/core/string/shared/replace.rb
@@ -57,19 +57,19 @@ describe :string_replace, shared: true do
   end
 
   it "raises a TypeError if other can't be converted to string" do
-    lambda { "hello".send(@method, 123)       }.should raise_error(TypeError)
-    lambda { "hello".send(@method, [])        }.should raise_error(TypeError)
-    lambda { "hello".send(@method, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".send(@method, 123)       }.should raise_error(TypeError)
+    -> { "hello".send(@method, [])        }.should raise_error(TypeError)
+    -> { "hello".send(@method, mock('x')) }.should raise_error(TypeError)
   end
 
   it "raises a #{frozen_error_class} on a frozen instance that is modified" do
     a = "hello".freeze
-    lambda { a.send(@method, "world") }.should raise_error(frozen_error_class)
+    -> { a.send(@method, "world") }.should raise_error(frozen_error_class)
   end
 
   # see [ruby-core:23666]
   it "raises a #{frozen_error_class} on a frozen instance when self-replacing" do
     a = "hello".freeze
-    lambda { a.send(@method, a) }.should raise_error(frozen_error_class)
+    -> { a.send(@method, a) }.should raise_error(frozen_error_class)
   end
 end
diff --git a/spec/ruby/core/string/shared/slice.rb b/spec/ruby/core/string/shared/slice.rb
index 697fa2e530..ef7a8787ce 100644
--- a/spec/ruby/core/string/shared/slice.rb
+++ b/spec/ruby/core/string/shared/slice.rb
@@ -21,17 +21,17 @@ describe :string_slice, shared: true do
   end
 
   it "raises a TypeError if the given index is nil" do
-    lambda { "hello".send(@method, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, nil) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if the given index can't be converted to an Integer" do
-    lambda { "hello".send(@method, mock('x')) }.should raise_error(TypeError)
-    lambda { "hello".send(@method, {})        }.should raise_error(TypeError)
-    lambda { "hello".send(@method, [])        }.should raise_error(TypeError)
+    -> { "hello".send(@method, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".send(@method, {})        }.should raise_error(TypeError)
+    -> { "hello".send(@method, [])        }.should raise_error(TypeError)
   end
 
   it "raises a RangeError if the index is too big" do
-    lambda { "hello".send(@method, bignum_value) }.should raise_error(RangeError)
+    -> { "hello".send(@method, bignum_value) }.should raise_error(RangeError)
   end
 end
 
@@ -140,23 +140,23 @@ describe :string_slice_index_length, shared: true do
   end
 
   it "raises a TypeError when idx or length can't be converted to an integer" do
-    lambda { "hello".send(@method, mock('x'), 0) }.should raise_error(TypeError)
-    lambda { "hello".send(@method, 0, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".send(@method, mock('x'), 0) }.should raise_error(TypeError)
+    -> { "hello".send(@method, 0, mock('x')) }.should raise_error(TypeError)
 
     # I'm deliberately including this here.
     # It means that str.send(@method, other, idx) isn't supported.
-    lambda { "hello".send(@method, "", 0) }.should raise_error(TypeError)
+    -> { "hello".send(@method, "", 0) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when the given index or the given length is nil" do
-    lambda { "hello".send(@method, 1, nil)   }.should raise_error(TypeError)
-    lambda { "hello".send(@method, nil, 1)   }.should raise_error(TypeError)
-    lambda { "hello".send(@method, nil, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, 1, nil)   }.should raise_error(TypeError)
+    -> { "hello".send(@method, nil, 1)   }.should raise_error(TypeError)
+    -> { "hello".send(@method, nil, nil) }.should raise_error(TypeError)
   end
 
   it "raises a RangeError if the index or length is too big" do
-    lambda { "hello".send(@method, bignum_value, 1) }.should raise_error(RangeError)
-    lambda { "hello".send(@method, 0, bignum_value) }.should raise_error(RangeError)
+    -> { "hello".send(@method, bignum_value, 1) }.should raise_error(RangeError)
+    -> { "hello".send(@method, 0, bignum_value) }.should raise_error(RangeError)
   end
 
   it "returns subclass instances" do
@@ -399,13 +399,13 @@ describe :string_slice_regexp_index, shared: true do
   end
 
   it "raises a TypeError when the given index can't be converted to Integer" do
-    lambda { "hello".send(@method, /(.)(.)(.)/, mock('x')) }.should raise_error(TypeError)
-    lambda { "hello".send(@method, /(.)(.)(.)/, {})        }.should raise_error(TypeError)
-    lambda { "hello".send(@method, /(.)(.)(.)/, [])        }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, {})        }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, [])        }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when the given index is nil" do
-    lambda { "hello".send(@method, /(.)(.)(.)/, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, nil) }.should raise_error(TypeError)
   end
 
   it "returns subclass instances" do
@@ -460,7 +460,7 @@ describe :string_slice_string, shared: true do
     o = mock('x')
     o.should_not_receive(:to_str)
 
-    lambda { "hello".send(@method, o) }.should raise_error(TypeError)
+    -> { "hello".send(@method, o) }.should raise_error(TypeError)
   end
 
   it "returns a subclass instance when given a subclass instance" do
@@ -520,19 +520,19 @@ describe :string_slice_regexp_group, shared: true do
     end
 
     it "raises an IndexError if there is no capture for the given name" do
-      lambda do
+      -> do
         "hello there".send(@method, /[aeiou](.)\1/, 'non')
       end.should raise_error(IndexError)
     end
 
     it "raises a TypeError when the given name is not a String" do
-      lambda { "hello".send(@method, /(?<q>.)/, mock('x')) }.should raise_error(TypeError)
-      lambda { "hello".send(@method, /(?<q>.)/, {})        }.should raise_error(TypeError)
-      lambda { "hello".send(@method, /(?<q>.)/, [])        }.should raise_error(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, mock('x')) }.should raise_error(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, {})        }.should raise_error(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, [])        }.should raise_error(TypeError)
     end
 
     it "raises an IndexError when given the empty String as a group name" do
-      lambda { "hello".send(@method, /(?<q>)/, '') }.should raise_error(IndexError)
+      -> { "hello".send(@method, /(?<q>)/, '') }.should raise_error(IndexError)
     end
 
     it "returns subclass instances" do
@@ -552,6 +552,6 @@ end
 
 describe :string_slice_symbol, shared: true do
   it "raises TypeError" do
-    lambda { 'hello'.send(@method, :hello) }.should raise_error(TypeError)
+    -> { 'hello'.send(@method, :hello) }.should raise_error(TypeError)
   end
 end
diff --git a/spec/ruby/core/string/shared/succ.rb b/spec/ruby/core/string/shared/succ.rb
index 0ab659864d..31b4a8b5dd 100644
--- a/spec/ruby/core/string/shared/succ.rb
+++ b/spec/ruby/core/string/shared/succ.rb
@@ -82,7 +82,7 @@ describe :string_succ_bang, shared: true do
   end
 
   it "raises a #{frozen_error_class} if self is frozen" do
-    lambda { "".freeze.send(@method)     }.should raise_error(frozen_error_class)
-    lambda { "abcd".freeze.send(@method) }.should raise_error(frozen_error_class)
+    -> { "".freeze.send(@method)     }.should raise_error(frozen_error_class)
+    -> { "abcd".freeze.send(@method) }.should raise_error(frozen_error_class)
   end
 end
author	Benoit Daloze <[email protected]>	2019-07-27 12:40:09 +0200
committer	Benoit Daloze <[email protected]>	2019-07-27 12:40:09 +0200
commit	5c276e1cc91c5ab2a41fbf7827af2fed914a2bc0 (patch)
tree	05b5c68c8b2a00224d4646ea3b26ce3877efaadd /spec/ruby/core/string/shared
parent	a06301b103371b0b7da8eaca26ba744961769f99 (diff)