[GR-14806] Update specs

PullRequest: truffleruby/3837

Author: eregon

ci.jsonnet

@@ -552,7 +552,7 @@ local composition_environment = utils.add_inclusion_tracking(part_definitions, "
       "ruby-test-svm-graal-core-darwin-aarch64-17":     $.platform.darwin_aarch64 + $.jdk.v17 + $.env.native    +                 gate + native_tests,
       "ruby-test-svm-graal-core-darwin-aarch64-20":     $.platform.darwin_aarch64 + $.jdk.v20 + $.env.native    +                 gate + native_tests,
       "ruby-test-svm-graal-enterprise-linux":           $.platform.linux          + $.jdk.v17 + $.env.native_ee + $.env.gdb_svm + gate + native_tests + $.env.host_inlining_log,
-      "ruby-test-svm-graal-enterprise-darwin-aarch64 ": $.platform.darwin_aarch64 + $.jdk.v17 + $.env.native_ee +                 gate + native_tests,
+      "ruby-test-svm-graal-enterprise-darwin-aarch64":  $.platform.darwin_aarch64 + $.jdk.v17 + $.env.native_ee +                 gate + native_tests,
     },
 
   local other_rubies = {

spec/ruby/.rubocop_todo.yml

@@ -98,6 +98,7 @@ Lint/RescueException:
     - 'core/dir/fileno_spec.rb'
     - 'core/exception/cause_spec.rb'
     - 'core/exception/no_method_error_spec.rb'
+    - 'core/fiber/kill_spec.rb'
     - 'core/kernel/fixtures/autoload_frozen.rb'
     - 'core/kernel/raise_spec.rb'
     - 'core/module/autoload_spec.rb'

spec/ruby/command_line/fixtures/bin/embedded_ruby.txt

@@ -1,3 +1,3 @@
 @@@This line is not value Ruby
 #!ruby
-puts 'success'
+puts 'success'

spec/ruby/core/array/assoc_spec.rb

@@ -6,7 +6,7 @@
     s1 = ["colors", "red", "blue", "green"]
     s2 = [:letters, "a", "b", "c"]
     s3 = [4]
-    s4 = ["colors", "cyan", "yellow", "magenda"]
+    s4 = ["colors", "cyan", "yellow", "magenta"]
     s5 = [:letters, "a", "i", "u"]
     s_nil = [nil, nil]
     a = [s1, s2, s3, s4, s5, s_nil]

spec/ruby/core/array/fill_spec.rb

@@ -52,11 +52,9 @@
   end
 
   it "raises an ArgumentError if 4 or more arguments are passed when no block given" do
-    -> { [].fill('a') }.should_not raise_error(ArgumentError)
-
-    -> { [].fill('a', 1) }.should_not raise_error(ArgumentError)
-
-    -> { [].fill('a', 1, 2) }.should_not raise_error(ArgumentError)
+    [].fill('a').should == []
+    [].fill('a', 1).should == []
+    [].fill('a', 1, 2).should == [nil, 'a', 'a']
     -> { [].fill('a', 1, 2, true) }.should raise_error(ArgumentError)
   end
 
@@ -65,11 +63,9 @@
   end
 
   it "raises an ArgumentError if 3 or more arguments are passed when a block given" do
-    -> { [].fill() {|i|} }.should_not raise_error(ArgumentError)
-
-    -> { [].fill(1) {|i|} }.should_not raise_error(ArgumentError)
-
-    -> { [].fill(1, 2) {|i|} }.should_not raise_error(ArgumentError)
+    [].fill() {|i|}.should == []
+    [].fill(1) {|i|}.should == []
+    [].fill(1, 2) {|i|}.should == [nil, nil, nil]
     -> { [].fill(1, 2, true) {|i|} }.should raise_error(ArgumentError)
   end
 
@@ -213,23 +209,23 @@
 
   # See: https://blade.ruby-lang.org/ruby-core/17481
   it "does not raise an exception if the given length is negative and its absolute value does not exceed the index" do
-    -> { [1, 2, 3, 4].fill('a', 3, -1)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill('a', 3, -2)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill('a', 3, -3)}.should_not raise_error(ArgumentError)
+    [1, 2, 3, 4].fill('a', 3, -1).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill('a', 3, -2).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill('a', 3, -3).should == [1, 2, 3, 4]
 
-    -> { [1, 2, 3, 4].fill(3, -1, &@never_passed)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill(3, -2, &@never_passed)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill(3, -3, &@never_passed)}.should_not raise_error(ArgumentError)
+    [1, 2, 3, 4].fill(3, -1, &@never_passed).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill(3, -2, &@never_passed).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill(3, -3, &@never_passed).should == [1, 2, 3, 4]
   end
 
   it "does not raise an exception even if the given length is negative and its absolute value exceeds the index" do
-    -> { [1, 2, 3, 4].fill('a', 3, -4)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill('a', 3, -5)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill('a', 3, -10000)}.should_not raise_error(ArgumentError)
+    [1, 2, 3, 4].fill('a', 3, -4).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill('a', 3, -5).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill('a', 3, -10000).should == [1, 2, 3, 4]
 
-    -> { [1, 2, 3, 4].fill(3, -4, &@never_passed)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill(3, -5, &@never_passed)}.should_not raise_error(ArgumentError)
-    -> { [1, 2, 3, 4].fill(3, -10000, &@never_passed)}.should_not raise_error(ArgumentError)
+    [1, 2, 3, 4].fill(3, -4, &@never_passed).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill(3, -5, &@never_passed).should == [1, 2, 3, 4]
+    [1, 2, 3, 4].fill(3, -10000, &@never_passed).should == [1, 2, 3, 4]
   end
 
   it "tries to convert the second and third arguments to Integers using #to_int" do

spec/ruby/core/dir/fchdir_spec.rb

@@ -2,17 +2,7 @@
 require_relative 'fixtures/common'
 
 ruby_version_is '3.3' do
-  has_fchdir = begin
-    dir = Dir.new('.')
-    Dir.fchdir(dir.fileno)
-    true
-  rescue NotImplementedError, NoMethodError
-    false
-  ensure
-    dir.close
-  end
-
-  guard -> { has_fchdir } do
+  guard -> { Dir.respond_to? :fchdir } do
     describe "Dir.fchdir" do
       before :all do
         DirSpecs.create_mock_dirs
@@ -67,7 +57,7 @@
     end
   end
 
-  guard_not -> { has_fchdir } do
+  guard_not -> { Dir.respond_to? :fchdir } do
     describe "Dir.fchdir" do
       it "raises NotImplementedError" do
         -> { Dir.fchdir 1 }.should raise_error(NotImplementedError)

spec/ruby/core/encoding/replicate_spec.rb

@@ -67,6 +67,14 @@
     end
   end
 
+  ruby_version_is "3.2"..."3.3" do
+    it "warns about deprecation" do
+      -> {
+        Encoding::US_ASCII.replicate('MY-US-ASCII')
+      }.should complain(/warning: Encoding#replicate is deprecated and will be removed in Ruby 3.3; use the original encoding instead/)
+    end
+  end
+
   ruby_version_is "3.3" do
     it "has been removed" do
       Encoding::US_ASCII.should_not.respond_to?(:replicate, true)

spec/ruby/core/enumerator/product_spec.rb

@@ -0,0 +1,88 @@
+require_relative '../../spec_helper'
+
+ruby_version_is "3.2" do
+  describe "Enumerator.product" do
+    it "returns a Cartesian product of enumerators" do
+      enum = Enumerator.product(1..2, ["A", "B"])
+      enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+    end
+
+    it "accepts a list of enumerators of any length" do
+      enum = Enumerator.product(1..2)
+      enum.to_a.should == [[1], [2]]
+
+      enum = Enumerator.product(1..2, ["A"])
+      enum.to_a.should == [[1, "A"], [2, "A"]]
+
+      enum = Enumerator.product(1..2, ["A"], ["B"])
+      enum.to_a.should == [[1, "A", "B"], [2, "A", "B"]]
+
+      enum = Enumerator.product(2..3, ["A"], ["B"], ["C"])
+      enum.to_a.should == [[2, "A", "B", "C"], [3, "A", "B", "C"]]
+    end
+
+    it "returns an enumerator with an empty array when no arguments passed" do
+      enum = Enumerator.product
+      enum.to_a.should == [[]]
+    end
+
+    it "returns an instance of Enumerator::Product" do
+      enum = Enumerator.product
+      enum.class.should == Enumerator::Product
+    end
+
+    it "accepts infinite enumerators and returns infinite enumerator" do
+      enum = Enumerator.product(1.., ["A", "B"])
+      enum.take(5).should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"], [3, "A"]]
+      enum.size.should == Float::INFINITY
+    end
+
+    it "accepts a block" do
+      elems = []
+      enum = Enumerator.product(1..2, ["X", "Y"]) { elems << _1 }
+
+      elems.should == [[1, "X"], [1, "Y"], [2, "X"], [2, "Y"]]
+    end
+
+    it "reject keyword arguments" do
+      -> {
+        Enumerator.product(1..3, foo: 1, bar: 2)
+      }.should raise_error(ArgumentError, "unknown keywords: :foo, :bar")
+    end
+
+    it "calls only #each_entry method on arguments" do
+      object = Object.new
+      def object.each_entry
+        yield 1
+        yield 2
+      end
+
+      enum = Enumerator.product(object, ["A", "B"])
+      enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+    end
+
+    it "raises NoMethodError when argument doesn't respond to #each_entry" do
+      -> {
+        Enumerator.product(Object.new).to_a
+      }.should raise_error(NoMethodError, /undefined method `each_entry' for/)
+    end
+
+    it "calls #each_entry lazily" do
+      Enumerator.product(Object.new).should be_kind_of(Enumerator)
+    end
+
+    it "iterates through consuming enumerator elements only once" do
+      a = [1, 2, 3]
+      i = 0
+
+      enum = Enumerator.new do |y|
+        while i < a.size
+          y << a[i]
+          i += 1
+        end
+      end
+
+      Enumerator.product(['a', 'b'], enum).to_a.should == [["a", 1], ["a", 2], ["a", 3]]
+    end
+  end
+end

spec/ruby/core/env/clone_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe "ENV#clone" do
+  it "raises ArgumentError when keyword argument 'freeze' is neither nil nor boolean" do
+    -> {
+      ENV.clone(freeze: 1)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError when keyword argument is not 'freeze'" do
+    -> {
+      ENV.clone(foo: nil)
+    }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is "3.2" do
+    it "raises TypeError" do
+      -> {
+        ENV.clone
+      }.should raise_error(TypeError, /Cannot clone ENV, use ENV.to_h to get a copy of ENV as a hash/)
+    end
+  end
+end

spec/ruby/core/env/dup_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../spec_helper'
+
+describe "ENV#dup" do
+  ruby_version_is "3.1" do
+    it "raises TypeError" do
+      -> {
+        ENV.dup
+      }.should raise_error(TypeError, /Cannot dup ENV, use ENV.to_h to get a copy of ENV as a hash/)
+    end
+  end
+end