Make assert_separately tolerant to core method redefinitions

And split `TestRubyOptimization#test_objtostring` for each target
class.

Author: nobu

test/ruby/test_optimization.rb

@@ -1080,7 +1080,7 @@ def test_optimized_rescue
   class Objtostring
   end
 
-  def test_objtostring
+  def test_objtostring_immediate
     assert_raise(NoMethodError){"#{BasicObject.new}"}
     assert_redefine_method('Symbol', 'to_s', <<-'end')
       assert_match %r{\A#<Symbol:0x[0-9a-f]+>\z}, "#{:foo}"
@@ -1094,11 +1094,17 @@ def test_objtostring
     assert_redefine_method('FalseClass', 'to_s', <<-'end')
       assert_match %r{\A#<FalseClass:0x[0-9a-f]+>\z}, "#{false}"
     end
+  end
+
+  def test_objtostring_fixnum
     assert_redefine_method('Integer', 'to_s', <<-'end')
       (-1..10).each { |i|
         assert_match %r{\A#<Integer:0x[0-9a-f]+>\z}, "#{i}"
       }
     end
+  end
+
+  def test_objtostring
     assert_equal "TestRubyOptimization::Objtostring", "#{Objtostring}"
     assert_match %r{\A#<Class:0x[0-9a-f]+>\z}, "#{Class.new}"
     assert_match %r{\A#<Module:0x[0-9a-f]+>\z}, "#{Module.new}"

tool/lib/core_assertions.rb

@@ -303,9 +303,35 @@ def assert_ruby_status(args, test_stdin="", message=nil, **opt)
 
       def separated_runner(token, out = nil)
         include(*Test::Unit::TestCase.ancestors.select {|c| !c.is_a?(Class) })
+
         out = out ? IO.new(out, 'w') : STDOUT
+
+        # avoid method redefinitions
+        out_write = out.method(:write)
+        integer_to_s = Integer.instance_method(:to_s)
+        array_pack = Array.instance_method(:pack)
+        marshal_dump = Marshal.method(:dump)
+        assertions_ivar_set = Test::Unit::Assertions.method(:instance_variable_set)
+        assertions_ivar_get = Test::Unit::Assertions.method(:instance_variable_get)
+        Test::Unit::Assertions.module_eval do
+          @_assertions = 0
+
+          undef _assertions=
+          define_method(:_assertions=, ->(n) {assertions_ivar_set.call(:@_assertions, n)})
+
+          undef _assertions
+          define_method(:_assertions, -> {assertions_ivar_get.call(:@_assertions)})
+        end
+        # assume Method#call and UnboundMethod#bind_call need to work as the original
+
         at_exit {
-          out.puts "#{token}<error>", [Marshal.dump($!)].pack('m'), "#{token}</error>", "#{token}assertions=#{self._assertions}"
+          assertions = assertions_ivar_get.call(:@_assertions)
+          out_write.call <<~OUT
+          #{token}<error>
+          #{array_pack.bind_call([marshal_dump.call($!)], 'm')}
+          #{token}</error>
+          #{token}assertions=#{integer_to_s.bind_call(assertions)}
+          OUT
         }
         if defined?(Test::Unit::Runner)
           Test::Unit::Runner.class_variable_set(:@@stop_auto_run, true)
@@ -360,7 +386,9 @@ def assert_separately(args, file = nil, line = nil, src, ignore_stderr: nil, **o
         raise if $!
         abort = status.coredump? || (status.signaled? && ABORT_SIGNALS.include?(status.termsig))
         assert(!abort, FailDesc[status, nil, stderr])
-        self._assertions += res[/^#{token_re}assertions=(\d+)/, 1].to_i
+        if (assertions = res[/^#{token_re}assertions=(\d+)/, 1].to_i) > 0
+          self._assertions += assertions
+        end
         begin
           res = Marshal.load(res[/^#{token_re}<error>\n\K.*\n(?=#{token_re}<\/error>$)/m].unpack1("m"))
         rescue => marshal_error