Update to ruby/spec@d8bacef

author: Andrew Konchin <[email protected]> 2025-05-07 13:08:11 +0300
committer: Benoit Daloze <[email protected]> 2025-05-09 23:22:15 +0200
commit: 269ad29de95e41cc8a4eede84b98a81a6ff4f7b6 (patch)
tree: 150acf5f6d6c2d401dd46b84b942af26b3699cc9 /spec/ruby/core/regexp
parent: 3135eddb4e8c6975b6fa5345f15fdaa55257851a (diff)
3 files changed, 83 insertions, 166 deletions
diff --git a/spec/ruby/core/regexp/linear_time_spec.rb b/spec/ruby/core/regexp/linear_time_spec.rb
index 4dc436264f..a6f8dccd46 100644
--- a/spec/ruby/core/regexp/linear_time_spec.rb
+++ b/spec/ruby/core/regexp/linear_time_spec.rb
@@ -1,25 +1,23 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Regexp.linear_time?" do
-    it "returns true if matching can be done in linear time" do
-      Regexp.linear_time?(/a/).should == true
-      Regexp.linear_time?('a').should == true
-    end
+describe "Regexp.linear_time?" do
+  it "returns true if matching can be done in linear time" do
+    Regexp.linear_time?(/a/).should == true
+    Regexp.linear_time?('a').should == true
+  end
 
-    it "return false if matching can't be done in linear time" do
-      Regexp.linear_time?(/(a)\1/).should == false
-      Regexp.linear_time?("(a)\\1").should == false
-    end
+  it "return false if matching can't be done in linear time" do
+    Regexp.linear_time?(/(a)\1/).should == false
+    Regexp.linear_time?("(a)\\1").should == false
+  end
 
-    it "accepts flags for string argument" do
-      Regexp.linear_time?('a', Regexp::IGNORECASE).should == true
-    end
+  it "accepts flags for string argument" do
+    Regexp.linear_time?('a', Regexp::IGNORECASE).should == true
+  end
 
-    it "warns about flags being ignored for regexp arguments" do
-      -> {
-        Regexp.linear_time?(/a/, Regexp::IGNORECASE)
-      }.should complain(/warning: flags ignored/)
-    end
+  it "warns about flags being ignored for regexp arguments" do
+    -> {
+      Regexp.linear_time?(/a/, Regexp::IGNORECASE)
+    }.should complain(/warning: flags ignored/)
   end
 end
diff --git a/spec/ruby/core/regexp/shared/new.rb b/spec/ruby/core/regexp/shared/new.rb
index 3ca50d5a47..44b339100e 100644
--- a/spec/ruby/core/regexp/shared/new.rb
+++ b/spec/ruby/core/regexp/shared/new.rb
@@ -123,140 +123,67 @@ describe :regexp_new_string, shared: true do
     (r.options & Regexp::EXTENDED).should_not == 0
   end
 
-  ruby_version_is ""..."3.2" do
-    it "does not try to convert the second argument to Integer with #to_int method call" do
-      ScratchPad.clear
-      obj = Object.new
-      def obj.to_int() ScratchPad.record(:called) end
+  it "does not try to convert the second argument to Integer with #to_int method call" do
+    ScratchPad.clear
+    obj = Object.new
+    def obj.to_int() ScratchPad.record(:called) end
 
+    -> {
       Regexp.send(@method, "Hi", obj)
+    }.should complain(/expected true or false as ignorecase/, {verbose: true})
 
-      ScratchPad.recorded.should == nil
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "does not try to convert the second argument to Integer with #to_int method call" do
-      ScratchPad.clear
-      obj = Object.new
-      def obj.to_int() ScratchPad.record(:called) end
-
-      -> {
-        Regexp.send(@method, "Hi", obj)
-      }.should complain(/expected true or false as ignorecase/, {verbose: true})
-
-      ScratchPad.recorded.should == nil
-    end
+    ScratchPad.recorded.should == nil
   end
 
-  ruby_version_is ""..."3.2" do
-    it "treats any non-Integer, non-nil, non-false second argument as IGNORECASE" do
+  it "warns any non-Integer, non-nil, non-false second argument" do
+    r = nil
+    -> {
       r = Regexp.send(@method, 'Hi', Object.new)
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "warns any non-Integer, non-nil, non-false second argument" do
-      r = nil
-      -> {
-        r = Regexp.send(@method, 'Hi', Object.new)
-      }.should complain(/expected true or false as ignorecase/, {verbose: true})
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-
-    it "accepts a String of supported flags as the second argument" do
-      r = Regexp.send(@method, 'Hi', 'i')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', 'imx')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should_not == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should_not == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', 'mimi')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should_not == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', '')
-      (r.options & Regexp::IGNORECASE).should == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-
-    it "raises an Argument error if the second argument contains unsupported chars" do
-      -> { Regexp.send(@method, 'Hi', 'e') }.should raise_error(ArgumentError, "unknown regexp option: e")
-      -> { Regexp.send(@method, 'Hi', 'n') }.should raise_error(ArgumentError, "unknown regexp option: n")
-      -> { Regexp.send(@method, 'Hi', 's') }.should raise_error(ArgumentError, "unknown regexp option: s")
-      -> { Regexp.send(@method, 'Hi', 'u') }.should raise_error(ArgumentError, "unknown regexp option: u")
-      -> { Regexp.send(@method, 'Hi', 'j') }.should raise_error(ArgumentError, "unknown regexp option: j")
-      -> { Regexp.send(@method, 'Hi', 'mjx') }.should raise_error(ArgumentError, /unknown regexp option: mjx\b/)
+    }.should complain(/expected true or false as ignorecase/, {verbose: true})
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
   end
 
-  ruby_version_is ""..."3.2" do
-    it "ignores the third argument if it is 'e' or 'euc' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 'e').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'euc').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'E').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'EUC').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+  it "accepts a String of supported flags as the second argument" do
+    r = Regexp.send(@method, 'Hi', 'i')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
 
-    it "ignores the third argument if it is 's' or 'sjis' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 's').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'sjis').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'S').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'SJIS').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+    r = Regexp.send(@method, 'Hi', 'imx')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should_not == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should_not == 0
     end
 
-    it "ignores the third argument if it is 'u' or 'utf8' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 'u').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'utf8').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'U').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'UTF8').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+    r = Regexp.send(@method, 'Hi', 'mimi')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should_not == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
 
-    it "uses US_ASCII encoding if third argument is 'n' or 'none' (case insensitive) and only ascii characters" do
-      Regexp.send(@method, 'Hi', nil, 'n').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'none').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'N').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'NONE').encoding.should == Encoding::US_ASCII
+    r = Regexp.send(@method, 'Hi', '')
+    (r.options & Regexp::IGNORECASE).should == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
+  end
 
-    it "uses ASCII_8BIT encoding if third argument is 'n' or 'none' (case insensitive) and non-ascii characters" do
-      a = "(?:[\x8E\xA1-\xFE])"
-      str = "\A(?:#{a}|x*)\z"
-
-      Regexp.send(@method, str, nil, 'N').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'n').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'none').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'NONE').encoding.should == Encoding::BINARY
-    end
+  it "raises an Argument error if the second argument contains unsupported chars" do
+    -> { Regexp.send(@method, 'Hi', 'e') }.should raise_error(ArgumentError, "unknown regexp option: e")
+    -> { Regexp.send(@method, 'Hi', 'n') }.should raise_error(ArgumentError, "unknown regexp option: n")
+    -> { Regexp.send(@method, 'Hi', 's') }.should raise_error(ArgumentError, "unknown regexp option: s")
+    -> { Regexp.send(@method, 'Hi', 'u') }.should raise_error(ArgumentError, "unknown regexp option: u")
+    -> { Regexp.send(@method, 'Hi', 'j') }.should raise_error(ArgumentError, "unknown regexp option: j")
+    -> { Regexp.send(@method, 'Hi', 'mjx') }.should raise_error(ArgumentError, /unknown regexp option: mjx\b/)
   end
 
   describe "with escaped characters" do
@@ -623,11 +550,5 @@ describe :regexp_new_regexp, shared: true do
     it "sets the encoding to US-ASCII if the Regexp literal has the 'n' option and the source String is ASCII only" do
       Regexp.send(@method, /Hi/n).encoding.should == Encoding::US_ASCII
     end
-
-    ruby_version_is ''...'3.2' do
-      it "sets the encoding to source String's encoding if the Regexp literal has the 'n' option and the source String is not ASCII only" do
-        Regexp.send(@method, Regexp.new("\\xff", nil, 'n')).encoding.should == Encoding::BINARY
-      end
-    end
   end
 end
diff --git a/spec/ruby/core/regexp/timeout_spec.rb b/spec/ruby/core/regexp/timeout_spec.rb
index 6fce261814..c64103c82c 100644
--- a/spec/ruby/core/regexp/timeout_spec.rb
+++ b/spec/ruby/core/regexp/timeout_spec.rb
@@ -1,35 +1,33 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Regexp.timeout" do
-    after :each do
-      Regexp.timeout = nil
-    end
+describe "Regexp.timeout" do
+  after :each do
+    Regexp.timeout = nil
+  end
 
-    it "returns global timeout" do
-      Regexp.timeout = 3
-      Regexp.timeout.should == 3
-    end
+  it "returns global timeout" do
+    Regexp.timeout = 3
+    Regexp.timeout.should == 3
+  end
 
-    it "raises Regexp::TimeoutError after global timeout elapsed" do
-      Regexp.timeout = 0.001
-      Regexp.timeout.should == 0.001
+  it "raises Regexp::TimeoutError after global timeout elapsed" do
+    Regexp.timeout = 0.001
+    Regexp.timeout.should == 0.001
 
-      -> {
-        # A typical ReDoS case
-        /^(a*)*$/ =~ "a" * 1000000 + "x"
-      }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
-    end
+    -> {
+      # A typical ReDoS case
+      /^(a*)*$/ =~ "a" * 1000000 + "x"
+    }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
+  end
 
-    it "raises Regexp::TimeoutError after timeout keyword value elapsed" do
-      Regexp.timeout = 3 # This should be ignored
-      Regexp.timeout.should == 3
+  it "raises Regexp::TimeoutError after timeout keyword value elapsed" do
+    Regexp.timeout = 3 # This should be ignored
+    Regexp.timeout.should == 3
 
-      re = Regexp.new("^a*b?a*$", timeout: 0.001)
+    re = Regexp.new("^a*b?a*$", timeout: 0.001)
 
-      -> {
-        re =~ "a" * 1000000 + "x"
-      }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
-    end
+    -> {
+      re =~ "a" * 1000000 + "x"
+    }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
   end
 end
author	Andrew Konchin <[email protected]>	2025-05-07 13:08:11 +0300
committer	Benoit Daloze <[email protected]>	2025-05-09 23:22:15 +0200
commit	269ad29de95e41cc8a4eede84b98a81a6ff4f7b6 (patch)
tree	150acf5f6d6c2d401dd46b84b942af26b3699cc9 /spec/ruby/core/regexp
parent	3135eddb4e8c6975b6fa5345f15fdaa55257851a (diff)