test-unit-ruby-core 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fbe8678b64c96aecfb825b2a2544e7089a681be164521d259880d07e5cf0589
-  data.tar.gz: 2726f59cb0cf549b49a1250d11324fe26f2eb93eb685740086bed65491b3f00f
+  metadata.gz: 3c827aeceb3fd1980fbc22e68e631c888f61852201f5a71d222137dccec7813e
+  data.tar.gz: f39f342ed03b29005052935840fca12eef139092dc6a9f30d53621e3947fa8d4
 SHA512:
-  metadata.gz: 3880a3106697e03f423822c456d1753755078378106d0e4bbfc7a2bbe7305a4860897aae9716dd77ab33a7b9503ef484beaa9a06bcdabd4bfa72f3036a191582
-  data.tar.gz: 9626368354be4eecb5c13a0d0fac687cd2c0ad8179315e899f1d27d564cd95b958ef07eea561d98102d362c56b49a08fac761c1e1dce7045afd7f84006aeddd3
+  metadata.gz: 38241758387cdd981ea6864ecab402c39d725ad38aea3b27835f73037c856a9a6c4b0792f671696d07f4ec9bfcf909d5c53a3dca31cd3076eb166d74d66e633d
+  data.tar.gz: 03e2d05f411ba5ccd86b1a82cb0aead6766ad13150a51c7d543d9a7fe266931c7744a562cce85f12a6c9c90317e481fdba70f7fd8a9d1a3ab30a815db5c85adb

data/lib/core_assertions.rb

@@ -97,11 +97,12 @@ module Test
       end
 
       def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil,
-                            success: nil, **opt)
+                            success: nil, failed: nil, **opt)
         args = Array(args).dup
         args.insert((Hash === args[0] ? 1 : 0), '--disable=gems')
         stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, **opt)
-        desc = FailDesc[status, message, stderr]
+        desc = failed[status, message, stderr] if failed
+        desc ||= FailDesc[status, message, stderr]
         if block_given?
           raise "test_stdout ignored, use block only or without block" if test_stdout != []
           raise "test_stderr ignored, use block only or without block" if test_stderr != []
@@ -495,14 +496,13 @@ eom
         case expected
         when String
           assert = :assert_equal
-        when Regexp
-          assert = :assert_match
         else
-          raise TypeError, "Expected #{expected.inspect} to be a kind of String or Regexp, not #{expected.class}"
+          assert_respond_to(expected, :===)
+          assert = :assert_match
         end
 
         ex = m = nil
-        EnvUtil.with_default_internal(expected.encoding) do
+        EnvUtil.with_default_internal(of: expected) do
           ex = assert_raise(exception, msg || proc {"Exception(#{exception}) with message matches to #{expected.inspect}"}) do
             yield
           end
@@ -520,6 +520,43 @@ eom
         ex
       end
 
+      # :call-seq:
+      #   assert_raise_kind_of(*args, &block)
+      #
+      #Tests if the given block raises one of the given exceptions or
+      #sub exceptions of the given exceptions.  If the last argument
+      #is a String, it will be used as the error message.
+      #
+      #    assert_raise do #Fails, no Exceptions are raised
+      #    end
+      #
+      #    assert_raise SystemCallErr do
+      #      Dir.chdir(__FILE__) #Raises Errno::ENOTDIR, so assertion succeeds
+      #    end
+      def assert_raise_kind_of(*exp, &b)
+        case exp.last
+        when String, Proc
+          msg = exp.pop
+        end
+
+        begin
+          yield
+        rescue Test::Unit::PendedError => e
+          raise e unless exp.include? Test::Unit::PendedError
+        rescue *exp => e
+          pass
+        rescue Exception => e
+          flunk(message(msg) {"#{mu_pp(exp)} family exception expected, not #{mu_pp(e)}"})
+        ensure
+          unless e
+            exp = exp.first if exp.size == 1
+
+            flunk(message(msg) {"#{mu_pp(exp)} family expected but nothing was raised"})
+          end
+        end
+        e
+      end
+
       TEST_DIR = File.join(__dir__, "test/unit") #:nodoc:
 
       # :call-seq:
@@ -639,7 +676,7 @@ eom
 
       def assert_warning(pat, msg = nil)
         result = nil
-        stderr = EnvUtil.with_default_internal(pat.encoding) {
+        stderr = EnvUtil.with_default_internal(of: pat) {
           EnvUtil.verbose_warning {
             result = yield
           }
@@ -653,17 +690,15 @@ eom
         assert_warning(*args) {$VERBOSE = false; yield}
       end
 
-      def assert_deprecated_warning(mesg = /deprecated/)
+      def assert_deprecated_warning(mesg = /deprecated/, &block)
         assert_warning(mesg) do
-          Warning[:deprecated] = true if Warning.respond_to?(:[]=)
-          yield
+          EnvUtil.deprecation_warning(&block)
         end
       end
 
-      def assert_deprecated_warn(mesg = /deprecated/)
+      def assert_deprecated_warn(mesg = /deprecated/, &block)
         assert_warn(mesg) do
-          Warning[:deprecated] = true if Warning.respond_to?(:[]=)
-          yield
+          EnvUtil.deprecation_warning(&block)
         end
       end
 
@@ -867,6 +902,82 @@ eom
         token = "\e[7;1m#{$$.to_s}:#{Time.now.strftime('%s.%L')}:#{rand(0x10000).to_s(16)}:\e[m"
         return token.dump, Regexp.quote(token)
       end
+
+      # Platform predicates
+
+      def self.mswin?
+        defined?(@mswin) ? @mswin : @mswin = RUBY_PLATFORM.include?('mswin')
+      end
+      private def mswin?
+        CoreAssertions.mswin?
+      end
+
+      def self.mingw?
+        defined?(@mingw) ? @mingw : @mingw = RUBY_PLATFORM.include?('mingw')
+      end
+      private def mingw?
+        CoreAssertions.mingw?
+      end
+
+      module_function def windows?
+        mswin? or mingw?
+      end
+
+      def self.version_compare(expected, actual)
+        expected.zip(actual).each {|e, a| z = (e <=> a); return z if z.nonzero?}
+        0
+      end
+
+      def self.version_match?(expected, actual)
+        if !actual
+          false
+        elsif expected.empty?
+          true
+        elsif expected.size == 1 and Range === (range = expected.first)
+          b, e = range.begin, range.end
+          return false if b and (c = version_compare(Array(b), actual)) > 0
+          return false if e and (c = version_compare(Array(e), actual)) < 0
+          return false if e and range.exclude_end? and c == 0
+          true
+        else
+          version_compare(expected, actual).zero?
+        end
+      end
+
+      def self.linux?(*ver)
+        unless defined?(@linux)
+          @linux = RUBY_PLATFORM.include?('linux') && `uname -r`.scan(/\d+/).map(&:to_i)
+        end
+        version_match? ver, @linux
+      end
+      private def linux?(*ver)
+        CoreAssertions.linux?(*ver)
+      end
+
+      def self.glibc?(*ver)
+        unless defined?(@glibc)
+          libc = `/usr/bin/ldd /bin/sh`[/^\s*libc.*=> *\K\S*/]
+          if libc and /version (\d+)\.(\d+)\.$/ =~ IO.popen([libc], &:read)[]
+            @glibc = [$1.to_i, $2.to_i]
+          else
+            @glibc = false
+          end
+        end
+        version_match? ver, @glibc
+      end
+      private def glibc?(*ver)
+        CoreAssertions.glibc?(*ver)
+      end
+
+      def self.macos?(*ver)
+        unless defined?(@macos)
+          @macos = RUBY_PLATFORM.include?('darwin') && `sw_vers -productVersion`.scan(/\d+/).map(&:to_i)
+        end
+        version_match? ver, @macos
+      end
+      private def macos?(*ver)
+        CoreAssertions.macos?(*ver)
+      end
     end
   end
 end

data/lib/envutil.rb

@@ -79,6 +79,70 @@ module EnvUtil
   end
   module_function :timeout
 
+  class Debugger
+    @list = []
+
+    attr_accessor :name
+
+    def self.register(name, &block)
+      @list << new(name, &block)
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+    end
+
+    def usable?; false; end
+
+    def start(pid, *args) end
+
+    def dump(pid, timeout: 60, reprieve: timeout&.div(4))
+      dpid = start(pid, *command_file(File.join(__dir__, "dump.#{name}")), out: :err)
+    rescue Errno::ENOENT
+      return
+    else
+      return unless dpid
+      [[timeout, :TERM], [reprieve, :KILL]].find do |t, sig|
+        return EnvUtil.timeout(t) {Process.wait(dpid)}
+      rescue Timeout::Error
+        Process.kill(sig, dpid)
+      end
+      true
+    end
+
+    # sudo -n: --non-interactive
+    PRECOMMAND = (%[sudo -n] if /darwin/ =~ RUBY_PLATFORM)
+
+    def spawn(*args, **opts)
+      super(*PRECOMMAND, *args, **opts)
+    end
+
+    register("gdb") do
+      class << self
+        def usable?; system(*%w[gdb --batch --quiet --nx -ex exit]); end
+        def start(pid, *args, **opts)
+          spawn(*%W[gdb --batch --quiet --pid #{pid}], *args, **opts)
+        end
+        def command_file(file) "--command=#{file}"; end
+      end
+    end
+
+    register("lldb") do
+      class << self
+        def usable?; system(*%w[lldb -Q --no-lldbinit -o exit]); end
+        def start(pid, *args, **opts)
+          spawn(*%W[lldb --batch -Q --attach-pid #{pid}], *args, **opts)
+        end
+        def command_file(file) ["--source", file]; end
+      end
+    end
+
+    def self.search
+      @debugger ||= @list.find(&:usable?)
+    end
+  end
+
   def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)
     reprieve = apply_timeout_scale(reprieve) if reprieve
 
@@ -94,17 +158,12 @@ module EnvUtil
       pgroup = pid
     end
 
-    lldb = true if /darwin/ =~ RUBY_PLATFORM
-
+    dumped = false
     while signal = signals.shift
 
-      if lldb and [:ABRT, :KILL].include?(signal)
-        lldb = false
-        # sudo -n: --non-interactive
-        # lldb -p: attach
-        #      -o: run command
-        system(*%W[sudo -n lldb -p #{pid} --batch -o bt\ all -o call\ rb_vmdebug_stack_dump_all_threads() -o quit])
-        true
+      if !dumped and [:ABRT, :KILL].include?(signal)
+        Debugger.search&.dump(pid)
+        dumped = true
       end
 
       begin
@@ -165,6 +224,11 @@ module EnvUtil
     }
 
     args = [args] if args.kind_of?(String)
+    # use the same parser as current ruby
+    if (args.none? { |arg| arg.start_with?("--parser=") } and
+        /^ +--parser=/ =~ IO.popen([rubybin, "--help"], &:read))
+      args = ["--parser=#{current_parser}"] + args
+    end
     pid = spawn(child_env, *precommand, rubybin, *args, opt)
     in_c.close
     out_c&.close
@@ -212,6 +276,12 @@ module EnvUtil
   end
   module_function :invoke_ruby
 
+  def current_parser
+    features = RUBY_DESCRIPTION[%r{\)\K [-+*/%._0-9a-zA-Z ]*(?=\[[-+*/%._0-9a-zA-Z]+\]\z)}]
+    features&.split&.include?("+PRISM") ? "prism" : "parse.y"
+  end
+  module_function :current_parser
+
   def verbose_warning
     class << (stderr = "".dup)
       alias write concat
@@ -228,6 +298,21 @@ module EnvUtil
   end
   module_function :verbose_warning
 
+  if defined?(Warning.[]=)
+    def deprecation_warning
+      previous_deprecated = Warning[:deprecated]
+      Warning[:deprecated] = true
+      yield
+    ensure
+      Warning[:deprecated] = previous_deprecated
+    end
+  else
+    def deprecation_warning
+      yield
+    end
+  end
+  module_function :deprecation_warning
+
   def default_warning
     $VERBOSE = false
     yield
@@ -254,11 +339,15 @@ module EnvUtil
 
   def under_gc_compact_stress(val = :empty, &block)
     raise "compaction doesn't work well on s390x. Omit the test in the caller." if RUBY_PLATFORM =~ /s390x/ # https://github.com/ruby/ruby/pull/5077
-    auto_compact = GC.auto_compact
-    GC.auto_compact = val
+
+    if GC.respond_to?(:auto_compact)
+      auto_compact = GC.auto_compact
+      GC.auto_compact = val
+    end
+
     under_gc_stress(&block)
   ensure
-    GC.auto_compact = auto_compact
+    GC.auto_compact = auto_compact if GC.respond_to?(:auto_compact)
   end
   module_function :under_gc_compact_stress
 
@@ -270,7 +359,8 @@ module EnvUtil
   end
   module_function :without_gc
 
-  def with_default_external(enc)
+  def with_default_external(enc = nil, of: nil)
+    enc = of.encoding if defined?(of.encoding)
     suppress_warning { Encoding.default_external = enc }
     yield
   ensure
@@ -278,7 +368,8 @@ module EnvUtil
   end
   module_function :with_default_external
 
-  def with_default_internal(enc)
+  def with_default_internal(enc = nil, of: nil)
+    enc = of.encoding if defined?(of.encoding)
     suppress_warning { Encoding.default_internal = enc }
     yield
   ensure

data/lib/memory_status.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+begin
+  require '-test-/memory_status.so'
+rescue LoadError
+end
+
+module Memory
+  keys = []
+
+  case
+  when File.exist?(procfile = "/proc/self/status") && (pat = /^Vm(\w+):\s+(\d+)/) =~ (data = File.binread(procfile))
+    PROC_FILE = procfile
+    VM_PAT = pat
+    def self.read_status
+      File.foreach(PROC_FILE, encoding: Encoding::ASCII_8BIT) do |l|
+        yield($1.downcase.intern, $2.to_i * 1024) if VM_PAT =~ l
+      end
+    end
+
+    data.scan(pat) {|k, v| keys << k.downcase.intern}
+
+  when /mswin|mingw/ =~ RUBY_PLATFORM
+    keys.push(:size, :rss, :peak)
+
+    begin
+      require 'fiddle/import'
+      require 'fiddle/types'
+    rescue LoadError
+      # Fallback to PowerShell command to get memory information for current process
+      def self.read_status
+        cmd = [
+          "powershell.exe", "-NoProfile", "-Command",
+          "Get-Process -Id #{$$} | " \
+          "% { Write-Output $_.PagedMemorySize64 $_.WorkingSet64 $_.PeakWorkingSet64 }"
+        ]
+
+        IO.popen(cmd, "r", err: [:child, :out]) do |out|
+          if /^(\d+)\n(\d+)\n(\d+)$/ =~ out.read
+            yield :size, $1.to_i
+            yield :rss, $2.to_i
+            yield :peak, $3.to_i
+          end
+        end
+      end
+    else
+      module Win32
+        extend Fiddle::Importer
+        dlload "kernel32.dll", "psapi.dll"
+        include Fiddle::Win32Types
+        typealias "SIZE_T", "size_t"
+
+        PROCESS_MEMORY_COUNTERS = struct [
+          "DWORD  cb",
+          "DWORD  PageFaultCount",
+          "SIZE_T PeakWorkingSetSize",
+          "SIZE_T WorkingSetSize",
+          "SIZE_T QuotaPeakPagedPoolUsage",
+          "SIZE_T QuotaPagedPoolUsage",
+          "SIZE_T QuotaPeakNonPagedPoolUsage",
+          "SIZE_T QuotaNonPagedPoolUsage",
+          "SIZE_T PagefileUsage",
+          "SIZE_T PeakPagefileUsage",
+        ]
+
+        typealias "PPROCESS_MEMORY_COUNTERS", "PROCESS_MEMORY_COUNTERS*"
+
+        extern "HANDLE GetCurrentProcess()", :stdcall
+        extern "BOOL GetProcessMemoryInfo(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD)", :stdcall
+
+        module_function
+        def memory_info
+          size = PROCESS_MEMORY_COUNTERS.size
+          data = PROCESS_MEMORY_COUNTERS.malloc
+          data.cb = size
+          data if GetProcessMemoryInfo(GetCurrentProcess(), data, size)
+        end
+      end
+
+      def self.read_status
+        if info = Win32.memory_info
+          yield :size, info.PagefileUsage
+          yield :rss, info.WorkingSetSize
+          yield :peak, info.PeakWorkingSetSize
+        end
+      end
+    end
+  when (require_relative 'find_executable'
+        pat = /^\s*(\d+)\s+(\d+)$/
+        pscmd = EnvUtil.find_executable("ps", "-ovsz=", "-orss=", "-p", $$.to_s) {|out| pat =~ out})
+    pscmd.pop
+    PAT = pat
+    PSCMD = pscmd
+
+    keys << :size << :rss
+    def self.read_status
+      if PAT =~ IO.popen(PSCMD + [$$.to_s], "r", err: [:child, :out], &:read)
+        yield :size, $1.to_i*1024
+        yield :rss, $2.to_i*1024
+      end
+    end
+  else
+    def self.read_status
+      raise NotImplementedError, "unsupported platform"
+    end
+  end
+
+  if !keys.empty?
+    Status = Struct.new(*keys)
+  end
+end unless defined?(Memory::Status)
+
+if defined?(Memory::Status)
+  class Memory::Status
+    def _update
+      Memory.read_status do |key, val|
+        self[key] = val
+      end
+      self
+    end unless method_defined?(:_update)
+
+    Header = members.map {|k| k.to_s.upcase.rjust(6)}.join('')
+    Format = "%6d"
+
+    def initialize
+      _update
+    end
+
+    def to_s
+      status = each_pair.map {|n,v|
+        "#{n}:#{v}"
+      }
+      "{#{status.join(",")}}"
+    end
+
+    def self.parse(str)
+      status = allocate
+      str.scan(/(?:\A\{|\G,)(#{members.join('|')}):(\d+)(?=,|\}\z)/) do
+        status[$1] = $2.to_i
+      end
+      status
+    end
+  end
+
+  # On some platforms (e.g. Solaris), libc malloc does not return
+  # freed memory to OS because of efficiency, and linking with extra
+  # malloc library is needed to detect memory leaks.
+  #
+  case RUBY_PLATFORM
+  when /solaris2\.(?:9|[1-9][0-9])/i # Solaris 9, 10, 11,...
+    bits = [nil].pack('p').size == 8 ? 64 : 32
+    if ENV['LD_PRELOAD'].to_s.empty? &&
+        ENV["LD_PRELOAD_#{bits}"].to_s.empty? &&
+        (ENV['UMEM_OPTIONS'].to_s.empty? ||
+         ENV['UMEM_OPTIONS'] == 'backend=mmap') then
+      envs = {
+        'LD_PRELOAD' => 'libumem.so',
+        'UMEM_OPTIONS' => 'backend=mmap'
+      }
+      args = [
+              envs,
+              "--disable=gems",
+              "-v", "-",
+             ]
+      _, err, status = EnvUtil.invoke_ruby(args, "exit(0)", true, true)
+      if status.exitstatus == 0 && err.to_s.empty? then
+        Memory::NO_MEMORY_LEAK_ENVS = envs
+      end
+    end
+  end #case RUBY_PLATFORM
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-unit-ruby-core
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.9
 platform: ruby
 authors:
 - Hiroshi SHIBATA
 - Nobu Nakada
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -35,6 +35,7 @@ files:
 - lib/core_assertions.rb
 - lib/envutil.rb
 - lib/find_executable.rb
+- lib/memory_status.rb
 homepage: https://github.com/ruby/test-unit-ruby-core
 licenses:
 - Ruby
@@ -56,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0.dev
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Additional test assertions for Ruby standard libraries.
 test_files: []