[pull] master from ruby:master

test/ruby/test_box.rb

@@ -28,23 +28,23 @@ def test_box_availability_in_default
     assert_separately(['RUBY_BOX'=>nil], __FILE__, __LINE__, "#{<<~"begin;"}\n#{<<~'end;'}", ignore_stderr: true)
     begin;
       assert_nil ENV['RUBY_BOX']
-      assert !Ruby::Box.enabled?
+      assert_not_predicate Ruby::Box, :enabled?
     end;
   end
 
   def test_box_availability_when_enabled
     assert_separately([ENV_ENABLE_BOX], __FILE__, __LINE__, "#{<<~"begin;"}\n#{<<~'end;'}", ignore_stderr: true)
     begin;
-      assert '1', ENV['RUBY_BOX']
-      assert Ruby::Box.enabled?
+      assert_equal '1', ENV['RUBY_BOX']
+      assert_predicate Ruby::Box, :enabled?
     end;
   end
 
   def test_current_box_in_main
     assert_separately([ENV_ENABLE_BOX], __FILE__, __LINE__, "#{<<~"begin;"}\n#{<<~'end;'}", ignore_stderr: true)
     begin;
       assert_equal Ruby::Box.main, Ruby::Box.current
-      assert Ruby::Box.main.main?
+      assert_predicate Ruby::Box.main, :main?
     end;
   end
 
@@ -152,7 +152,7 @@ def test_raising_errors_in_require
     setup_box
 
     assert_raise(RuntimeError, "Yay!") { @box.require(File.join(__dir__, 'box', 'raise')) }
-    assert Ruby::Box.current.inspect.include?("main")
+    assert_include Ruby::Box.current.inspect, "main"
   end
 
   def test_autoload_in_box
@@ -514,7 +514,7 @@ def test_global_variables
     assert_equal nil, $,
 
     # used only in box
-    assert !global_variables.include?(:$used_only_in_box)
+    assert_not_include? global_variables, :$used_only_in_box
     @box::UniqueGvar.write(123)
     assert_equal 123, @box::UniqueGvar.read
     assert_nil $used_only_in_box
@@ -535,7 +535,7 @@ def test_global_variables
   def test_load_path_and_loaded_features
     setup_box
 
-    assert $LOAD_PATH.respond_to?(:resolve_feature_path)
+    assert_respond_to $LOAD_PATH, :resolve_feature_path
 
     @box.require_relative('box/load_path')
 
@@ -545,13 +545,13 @@ def test_load_path_and_loaded_features
 
     box_dir = File.join(__dir__, 'box')
     # TODO: $LOADED_FEATURES in method calls should refer the current box in addition to the loading box.
-    # assert @box::LoadPathCheck.current_loaded_features.include?(File.join(box_dir, 'blank1.rb'))
-    # assert !@box::LoadPathCheck.current_loaded_features.include?(File.join(box_dir, 'blank2.rb'))
-    # assert @box::LoadPathCheck.require_blank2
-    # assert @box::LoadPathCheck.current_loaded_features.include?(File.join(box_dir, 'blank2.rb'))
+    # assert_include @box::LoadPathCheck.current_loaded_features, File.join(box_dir, 'blank1.rb')
+    # assert_not_include @box::LoadPathCheck.current_loaded_features, File.join(box_dir, 'blank2.rb')
+    # assert_predicate @box::LoadPathCheck, :require_blank2
+    # assert_include(@box::LoadPathCheck.current_loaded_features, File.join(box_dir, 'blank2.rb'))
 
-    assert !$LOADED_FEATURES.include?(File.join(box_dir, 'blank1.rb'))
-    assert !$LOADED_FEATURES.include?(File.join(box_dir, 'blank2.rb'))
+    assert_not_include $LOADED_FEATURES, File.join(box_dir, 'blank1.rb')
+    assert_not_include $LOADED_FEATURES, File.join(box_dir, 'blank2.rb')
   end
 
   def test_eval_basic
@@ -690,23 +690,23 @@ def test_root_and_main_methods
     begin;
       pend unless Ruby::Box.respond_to?(:root) and Ruby::Box.respond_to?(:main) # for RUBY_DEBUG > 0
 
-      assert Ruby::Box.root.respond_to?(:root?)
-      assert Ruby::Box.main.respond_to?(:main?)
+      assert_respond_to Ruby::Box.root, :root?
+      assert_respond_to Ruby::Box.main, :main?
 
-      assert Ruby::Box.root.root?
-      assert Ruby::Box.main.main?
+      assert_predicate Ruby::Box.root, :root?
+      assert_predicate Ruby::Box.main, :main?
       assert_equal Ruby::Box.main, Ruby::Box.current
 
       $a = 1
       $LOADED_FEATURES.push("/tmp/foobar")
 
       assert_equal 2, Ruby::Box.root.eval('$a = 2; $a')
-      assert !Ruby::Box.root.eval('$LOADED_FEATURES.push("/tmp/barbaz"); $LOADED_FEATURES.include?("/tmp/foobar")')
-      assert "FooClass", Ruby::Box.root.eval('class FooClass; end; Object.const_get(:FooClass).to_s')
+      assert_not_include Ruby::Box.root.eval('$LOADED_FEATURES.push("/tmp/barbaz"); $LOADED_FEATURES'), "/tmp/foobar"
+      assert_equal "FooClass", Ruby::Box.root.eval('class FooClass; end; Object.const_get(:FooClass).to_s')
 
       assert_equal 1, $a
-      assert !$LOADED_FEATURES.include?("/tmp/barbaz")
-      assert !Object.const_defined?(:FooClass)
+      assert_not_include $LOADED_FEATURES, "/tmp/barbaz"
+      assert_not_operator Object, :const_defined?, :FooClass
     end;
   end
 

test/ruby/test_encoding.rb

@@ -154,7 +154,7 @@ def test_ractor_lazy_load_encoding_concurrently
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end
 
@@ -173,7 +173,7 @@ def test_ractor_set_default_external_string
       r, _obj = Ractor.select(*rs)
       rs.delete(r)
     end
-    assert rs.empty?
+    assert_empty rs
     end;
   end
 end

test/ruby/test_env.rb

@@ -1379,23 +1379,24 @@ def test_frozen_in_ractor
       Ractor.new port = Ractor::Port.new do |port|
         ENV["#{PATH_ENV}"] = "/"
         ENV.each do |k, v|
-          port.send [k.frozen?]
-          port.send [v.frozen?]
+          port.send [k]
+          port.send [v]
         end
         ENV.each_key do |k|
-          port.send [k.frozen?]
+          port.send [k]
         end
         ENV.each_value do |v|
-          port.send [v.frozen?]
+          port.send [v]
         end
         ENV.each_key do |k|
-          port.send [ENV[k].frozen?, "[\#{k.dump}]"]
-          port.send [ENV.fetch(k).frozen?, "fetch(\#{k.dump})"]
+          port.send [ENV[k], "[\#{k.dump}]"]
+          port.send [ENV.fetch(k), "fetch(\#{k.dump})"]
         end
         port.send "finished"
       end
       while((params=port.receive) != "finished")
-        assert(*params)
+        value, *params = params
+        assert_predicate(value, :frozen?, *params)
       end
     end;
   end

test/ruby/test_exception.rb

@@ -992,7 +992,7 @@ def test_output_string_encoding
       assert_equal 1, outs.size
       assert_equal 0, errs.size
       err = outs.first.force_encoding('utf-8')
-      assert err.valid_encoding?, 'must be valid encoding'
+      assert_predicate err, :valid_encoding?
       assert_match %r/\u3042/, err
     end
   end

test/ruby/test_gc_compact.rb

@@ -30,7 +30,7 @@ class AutoCompact < Test::Unit::TestCase
     def test_enable_autocompact
       before = GC.auto_compact
       GC.auto_compact = true
-      assert GC.auto_compact
+      assert_predicate GC, :auto_compact
     ensure
       GC.auto_compact = before
     end
@@ -151,12 +151,12 @@ def test_ast_compacts
       def walk_ast ast
         children = ast.children.grep(RubyVM::AbstractSyntaxTree::Node)
         children.each do |child|
-          assert child.type
+          assert_predicate child, :type
           walk_ast child
         end
       end
       ast = RubyVM::AbstractSyntaxTree.parse_file #{__FILE__.dump}
-      assert GC.compact
+      assert_predicate GC, :compact
       walk_ast ast
     end;
   end

test/ruby/test_io_buffer.rb

@@ -46,22 +46,22 @@ def test_default_size
   def test_new_internal
     buffer = IO::Buffer.new(1024, IO::Buffer::INTERNAL)
     assert_equal 1024, buffer.size
-    refute buffer.external?
-    assert buffer.internal?
-    refute buffer.mapped?
+    refute_predicate buffer, :external?
+    assert_predicate buffer, :internal?
+    refute_predicate buffer, :mapped?
   end
 
   def test_new_mapped
     buffer = IO::Buffer.new(1024, IO::Buffer::MAPPED)
     assert_equal 1024, buffer.size
-    refute buffer.external?
-    refute buffer.internal?
-    assert buffer.mapped?
+    refute_predicate buffer, :external?
+    refute_predicate buffer, :internal?
+    assert_predicate buffer, :mapped?
   end
 
   def test_new_readonly
     buffer = IO::Buffer.new(128, IO::Buffer::INTERNAL|IO::Buffer::READONLY)
-    assert buffer.readonly?
+    assert_predicate buffer, :readonly?
 
     assert_raise IO::Buffer::AccessError do
       buffer.set_string("")
@@ -141,19 +141,19 @@ def test_file_mapped_invalid
   def test_string_mapped
     string = "Hello World"
     buffer = IO::Buffer.for(string)
-    assert buffer.readonly?
+    assert_predicate buffer, :readonly?
   end
 
   def test_string_mapped_frozen
     string = "Hello World".freeze
     buffer = IO::Buffer.for(string)
-    assert buffer.readonly?
+    assert_predicate buffer, :readonly?
   end
 
   def test_string_mapped_mutable
     string = "Hello World"
     IO::Buffer.for(string) do |buffer|
-      refute buffer.readonly?
+      refute_predicate buffer, :readonly?
 
       buffer.set_value(:U8, 0, "h".ord)
 
@@ -715,8 +715,8 @@ def test_private
 
       buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::PRIVATE)
       begin
-        assert buffer.private?
-        refute buffer.readonly?
+        assert_predicate buffer, :private?
+        refute_predicate buffer, :readonly?
 
         buffer.set_string("J")
 

test/ruby/test_module.rb

@@ -9,18 +9,18 @@ def _wrap_assertion
     yield
   end
 
-  def assert_method_defined?(klass, mid, message="")
+  def assert_method_defined?(klass, (mid, *args), message="")
     message = build_message(message, "#{klass}\##{mid} expected to be defined.")
     _wrap_assertion do
-      klass.method_defined?(mid) or
+      klass.method_defined?(mid, *args) or
         raise Test::Unit::AssertionFailedError, message, caller(3)
     end
   end
 
-  def assert_method_not_defined?(klass, mid, message="")
+  def assert_method_not_defined?(klass, (mid, *args), message="")
     message = build_message(message, "#{klass}\##{mid} expected to not be defined.")
     _wrap_assertion do
-      klass.method_defined?(mid) and
+      klass.method_defined?(mid, *args) and
         raise Test::Unit::AssertionFailedError, message, caller(3)
     end
   end
@@ -813,40 +813,40 @@ def test_instance_methods
   def test_method_defined?
     [User, Class.new{include User}, Class.new{prepend User}].each do |klass|
       [[], [true]].each do |args|
-        assert !klass.method_defined?(:wombat, *args)
-        assert klass.method_defined?(:mixin, *args)
-        assert klass.method_defined?(:user, *args)
-        assert klass.method_defined?(:user2, *args)
-        assert !klass.method_defined?(:user3, *args)
+        assert_method_not_defined?(klass, [:wombat, *args])
+        assert_method_defined?(klass, [:mixin, *args])
+        assert_method_defined?(klass, [:user, *args])
+        assert_method_defined?(klass, [:user2, *args])
+        assert_method_not_defined?(klass, [:user3, *args])
 
-        assert !klass.method_defined?("wombat", *args)
-        assert klass.method_defined?("mixin", *args)
-        assert klass.method_defined?("user", *args)
-        assert klass.method_defined?("user2", *args)
-        assert !klass.method_defined?("user3", *args)
+        assert_method_not_defined?(klass, ["wombat", *args])
+        assert_method_defined?(klass, ["mixin", *args])
+        assert_method_defined?(klass, ["user", *args])
+        assert_method_defined?(klass, ["user2", *args])
+        assert_method_not_defined?(klass, ["user3", *args])
       end
     end
   end
 
   def test_method_defined_without_include_super
-    assert User.method_defined?(:user, false)
-    assert !User.method_defined?(:mixin, false)
-    assert Mixin.method_defined?(:mixin, false)
+    assert_method_defined?(User, [:user, false])
+    assert_method_not_defined?(User, [:mixin, false])
+    assert_method_defined?(Mixin, [:mixin, false])
 
     User.const_set(:FOO, c = Class.new)
 
     c.prepend(User)
-    assert !c.method_defined?(:user, false)
+    assert_method_not_defined?(c, [:user, false])
     c.define_method(:user){}
-    assert c.method_defined?(:user, false)
+    assert_method_defined?(c, [:user, false])
 
-    assert !c.method_defined?(:mixin, false)
+    assert_method_not_defined?(c, [:mixin, false])
     c.define_method(:mixin){}
-    assert c.method_defined?(:mixin, false)
+    assert_method_defined?(c, [:mixin, false])
 
-    assert !c.method_defined?(:userx, false)
+    assert_method_not_defined?(c, [:userx, false])
     c.define_method(:userx){}
-    assert c.method_defined?(:userx, false)
+    assert_method_defined?(c, [:userx, false])
 
     # cleanup
     User.class_eval do

test/ruby/test_nomethod_error.rb

@@ -78,7 +78,7 @@ def test_new_receiver
     assert_equal :foo, error.name
     assert_equal [1, 2], error.args
     assert_equal receiver, error.receiver
-    assert error.private_call?, "private_call? was false."
+    assert_predicate error, :private_call?
   end
 
   def test_message_encoding

test/ruby/test_parse.rb

@@ -1588,7 +1588,7 @@ def test_shareable_constant_value_simple
     assert_ractor_shareable(a)
     assert_not_ractor_shareable(obj)
     assert_equal obj, a
-    assert !obj.equal?(a)
+    assert_not_same obj, a
 
     bug_20339 = '[ruby-core:117186] [Bug #20339]'
     bug_20341 = '[ruby-core:117197] [Bug #20341]'

test/ruby/test_signal.rb

@@ -320,15 +320,15 @@ def test_self_stop
 
     # The parent should be notified about the stop
     _, status = Process.waitpid2(child_pid, Process::WUNTRACED)
-    assert status.stopped?
+    assert_predicate status, :stopped?
 
     # It can be continued
     Process.kill(:CONT, child_pid)
 
     # And the child then runs to completion
     _, status = Process.waitpid2(child_pid)
-    assert status.exited?
-    assert status.success?
+    assert_predicate status, :exited?
+    assert_predicate status, :success?
   end
 
   def test_sigwait_fd_unused