Prefer dedicated assertions

12 files changed, 82 insertions, 81 deletions

diff --git a/test/ruby/test_box.rb b/test/ruby/test_box.rb
index 763f6148cb..bb98a2efbe 100644
--- a/test/ruby/test_box.rb
+++ b/test/ruby/test_box.rb
@@ -28,15 +28,15 @@ class TestBox < Test::Unit::TestCase
     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
 
@@ -44,7 +44,7 @@ class TestBox < Test::Unit::TestCase
     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 @@ class TestBox < Test::Unit::TestCase
     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 @@ class TestBox < Test::Unit::TestCase
     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 @@ class TestBox < Test::Unit::TestCase
   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 @@ class TestBox < Test::Unit::TestCase
 
     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 @@ class TestBox < Test::Unit::TestCase
     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
 
diff --git a/test/ruby/test_encoding.rb b/test/ruby/test_encoding.rb
index 5c1eb50bb1..0cd5bf49dc 100644
--- a/test/ruby/test_encoding.rb
+++ b/test/ruby/test_encoding.rb
@@ -154,7 +154,7 @@ class TestEncoding < Test::Unit::TestCase
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end
 
@@ -173,7 +173,7 @@ class TestEncoding < Test::Unit::TestCase
       r, _obj = Ractor.select(*rs)
       rs.delete(r)
     end
-    assert rs.empty?
+    assert_empty rs
     end;
   end
 end
diff --git a/test/ruby/test_env.rb b/test/ruby/test_env.rb
index 2727620c19..d17e300bce 100644
--- a/test/ruby/test_env.rb
+++ b/test/ruby/test_env.rb
@@ -1379,23 +1379,24 @@ class TestEnv < Test::Unit::TestCase
       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
diff --git a/test/ruby/test_exception.rb b/test/ruby/test_exception.rb
index 17ff5a2e82..31e5aa9f6b 100644
--- a/test/ruby/test_exception.rb
+++ b/test/ruby/test_exception.rb
@@ -992,7 +992,7 @@ $stderr = $stdout; raise "\x82\xa0"') do |outs, errs, status|
       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
diff --git a/test/ruby/test_gc_compact.rb b/test/ruby/test_gc_compact.rb
index a03535171c..bc7692d644 100644
--- a/test/ruby/test_gc_compact.rb
+++ b/test/ruby/test_gc_compact.rb
@@ -30,7 +30,7 @@ class TestGCCompact < 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 @@ class TestGCCompact < Test::Unit::TestCase
       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
diff --git a/test/ruby/test_io_buffer.rb b/test/ruby/test_io_buffer.rb
index e996fc39b8..706ce16c42 100644
--- a/test/ruby/test_io_buffer.rb
+++ b/test/ruby/test_io_buffer.rb
@@ -46,22 +46,22 @@ class TestIOBuffer < Test::Unit::TestCase
   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 @@ class TestIOBuffer < Test::Unit::TestCase
   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 @@ class TestIOBuffer < Test::Unit::TestCase
 
       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")
 
diff --git a/test/ruby/test_module.rb b/test/ruby/test_module.rb
index 30a7c5d9bc..3db60dec8f 100644
--- a/test/ruby/test_module.rb
+++ b/test/ruby/test_module.rb
@@ -9,18 +9,18 @@ class TestModule < Test::Unit::TestCase
     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 @@ class TestModule < Test::Unit::TestCase
   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
diff --git a/test/ruby/test_nomethod_error.rb b/test/ruby/test_nomethod_error.rb
index aa2a88b2d8..6abd20cc81 100644
--- a/test/ruby/test_nomethod_error.rb
+++ b/test/ruby/test_nomethod_error.rb
@@ -78,7 +78,7 @@ class TestNoMethodError < Test::Unit::TestCase
     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
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index 9fa4dad41e..def41d6017 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -1588,7 +1588,7 @@ x = __ENCODING__
     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]'
diff --git a/test/ruby/test_signal.rb b/test/ruby/test_signal.rb
index a2bdf02b88..661ba03141 100644
--- a/test/ruby/test_signal.rb
+++ b/test/ruby/test_signal.rb
@@ -320,15 +320,15 @@ class TestSignal < Test::Unit::TestCase
 
     # 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
diff --git a/test/ruby/test_thread_queue.rb b/test/ruby/test_thread_queue.rb
index 9485528977..9a41be8b1a 100644
--- a/test/ruby/test_thread_queue.rb
+++ b/test/ruby/test_thread_queue.rb
@@ -379,7 +379,7 @@ class TestThreadQueue < Test::Unit::TestCase
       assert_equal false, q.closed?
       q << :something
       assert_equal q, q.close
-      assert q.closed?
+      assert_predicate q, :closed?
       assert_raise_with_message(ClosedQueueError, /closed/){q << :nothing}
       assert_equal q.pop, :something
       assert_nil q.pop
@@ -433,7 +433,7 @@ class TestThreadQueue < Test::Unit::TestCase
 
     assert_equal 1, q.size
     assert_equal :one, q.pop
-    assert q.empty?, "queue not empty"
+    assert_empty q
   end
 
   # make sure that shutdown state is handled properly by empty? for the non-blocking case
@@ -567,7 +567,7 @@ class TestThreadQueue < Test::Unit::TestCase
     assert_equal 0, q.size
 
     assert_equal 3, ary.size
-    ary.each{|e| assert [0,1,2,3,4,5].include?(e)}
+    ary.each{|e| assert_include [0,1,2,3,4,5], e}
     assert_nil q.pop
 
     prod_threads.each{|t|
diff --git a/test/ruby/test_transcode.rb b/test/ruby/test_transcode.rb
index 15e290728b..99b5ee8d43 100644
--- a/test/ruby/test_transcode.rb
+++ b/test/ruby/test_transcode.rb
@@ -2338,7 +2338,7 @@ class TestTranscode < Test::Unit::TestCase
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end
 
@@ -2357,7 +2357,7 @@ class TestTranscode < Test::Unit::TestCase
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end
 
@@ -2380,7 +2380,7 @@ class TestTranscode < Test::Unit::TestCase
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end
 
@@ -2403,7 +2403,7 @@ class TestTranscode < Test::Unit::TestCase
         r, _obj = Ractor.select(*rs)
         rs.delete(r)
       end
-      assert rs.empty?
+      assert_empty rs
     end;
   end