henitai 0.5.3 → 0.6.0

data/lib/henitai/cli/run_command.rb

@@ -43,7 +43,8 @@ module Henitai
           survivors_from: resolved_survivors_from,
           mode: {
             dry_run: options.fetch(:dry_run, false),
-            incremental: options.fetch(:incremental, false) && !options.fetch(:force, false)
+            incremental: options.fetch(:incremental, false) && !options.fetch(:force, false),
+            force: options.fetch(:force, false)
           }
         )
         runner.run
@@ -64,7 +65,7 @@ module Henitai
         # being a snapshot path; this keeps activation-recipes lookup correct.
         return survivors_from if File.basename(parent_dir) == "sessions"
 
-        session_id = session_id_from_report(survivors_from)
+        session_id = single_session_id_from_report(survivors_from)
         return survivors_from if session_id.nil?
 
         snapshot_path = survivors_snapshot_path(report_dir, session_id)
@@ -85,9 +86,16 @@ module Henitai
         File.join(report_dir, "sessions", session_id, "mutation-report.json")
       end
 
-      def session_id_from_report(path)
+      # The report's sessionId only names a snapshot holding every survivor when
+      # each file entry was produced by that very session. A merged canonical
+      # report (or a legacy one without per-file provenance) is used as is.
+      def single_session_id_from_report(path)
         parsed = JSON.parse(File.read(path))
-        parsed["sessionId"]
+        session_id = parsed["sessionId"]
+        files = parsed["files"]
+        return nil unless files.is_a?(Hash) && files.each_value.all? { |f| f["sessionId"] == session_id }
+
+        session_id
       rescue JSON::ParserError, Errno::ENOENT
         nil
       end
@@ -104,6 +112,18 @@ module Henitai
         strict_status || threshold_status_for(result, config)
       end
 
+      # An empty score denominator passes only when there was nothing to score
+      # (no changed code, everything ignored). When harness errors emptied it,
+      # nothing was tested, and the run must not pass its threshold.
+      def empty_score_status(result)
+        harness_errors = result.mutants.count { |mutant| mutant.status == :compile_error }
+        return 0 if harness_errors.zero?
+
+        warn "henitai: no mutant could be scored: #{harness_errors} harness error(s) " \
+             "(CompileError, see statusReason in the report)"
+        1
+      end
+
       # Expanded, opt-in exit codes (precedence: timeout > runtime/compile
       # error > threshold miss). The timeout code is informational and
       # independent of coverage_criteria.timeout: a run can pass its threshold
@@ -118,9 +138,7 @@ module Henitai
 
       def threshold_status_for(result, config)
         score = result.mutation_score
-        # No valid mutants to evaluate (e.g. an incremental run with no changed
-        # code) cannot fail a threshold — treat it as success.
-        return 0 if score.nil?
+        return empty_score_status(result) if score.nil?
 
         score.to_i >= config.thresholds.fetch(:low, 60) ? 0 : 1
       end

data/lib/henitai/cli/run_options.rb

@@ -79,7 +79,7 @@ module Henitai
       def add_force_option(opts, options)
         opts.on(
           "--force",
-          "Bypass verdict reuse and execute every mutant (only meaningful with --incremental)"
+          "Bypass verdict reuse (--incremental, --survivors-from) and execute every mutant"
         ) do
           options[:force] = true
         end

data/lib/henitai/cli.rb

@@ -37,7 +37,10 @@ module Henitai
       %w[coverage .resultset.json],
       %w[coverage .last_run.json],
       ["henitai_per_test.json"],
-      [CoverageBootstrapper::DEPENDENCY_MANIFEST_FILE]
+      [PerTestCoverageCollector::BOOT_FILE_NAME],
+      [CoverageBootstrapper::DEPENDENCY_MANIFEST_FILE],
+      [FlakyTestRegistry::FILE_NAME],
+      [TestFileOutcomes::REPORT_FILE_NAME]
     ].freeze
 
     # Whole directories of per-mutant scratch artifacts, removed recursively.

data/lib/henitai/configuration.rb

@@ -43,7 +43,7 @@ module Henitai
 
     attr_reader :integration, :includes, :excludes, :test_excludes, :operators, :timeout,
                 :timeout_multiplier, :ignore_patterns, :sampling, :jobs,
-                :max_flaky_retries, :max_log_bytes, :max_timeout,
+                :max_flaky_retries, :max_log_bytes, :max_timeout, :control_runs, :flaky_detection, :fork_server,
                 :coverage_criteria, :thresholds,
                 :reporters, :reports_dir,
                 :checkpoint_enabled, :checkpoint_every, :checkpoint_interval,
@@ -124,6 +124,9 @@ module Henitai
       @max_flaky_retries = mutation.fetch(:max_flaky_retries, DEFAULT_MAX_FLAKY_RETRIES)
       @max_log_bytes = mutation[:max_log_bytes] || DEFAULT_MAX_LOG_BYTES
       @max_timeout = mutation[:max_timeout] || DEFAULT_MAX_TIMEOUT
+      @control_runs = mutation.fetch(:control_runs, true)
+      @flaky_detection = mutation.fetch(:flaky_detection, false)
+      @fork_server = mutation.fetch(:fork_server, false)
     end
 
     def apply_reports_defaults(raw)

data/lib/henitai/configuration_validator/rules.rb

@@ -100,6 +100,13 @@ module Henitai
         Scalars.validate_max_flaky_retries(value[:max_flaky_retries])
         Scalars.validate_max_log_bytes(value[:max_log_bytes])
         Scalars.validate_max_timeout(value[:max_timeout])
+        validate_mutation_flags(value)
+      end
+
+      def validate_mutation_flags(value)
+        %i[control_runs flaky_detection fork_server].each do |key|
+          Scalars.validate_boolean(value[key], "mutation.#{key}") unless value[key].nil?
+        end
       end
 
       def validate_mutation_filters(value)
@@ -133,6 +140,7 @@ module Henitai
         Scalars.validate_sampling_completeness(value)
         Scalars.validate_sampling_ratio(value[:ratio])
         Scalars.validate_sampling_strategy(value[:strategy])
+        Scalars.validate_sampling_seed(value[:seed])
       end
 
       def warn_unknown_keys(raw, allowed_keys, path = nil)

data/lib/henitai/configuration_validator/scalars.rb

@@ -150,6 +150,15 @@ module Henitai
         )
       end
 
+      def validate_sampling_seed(value)
+        return if value.nil?
+        return if value.is_a?(Integer) && value >= 0
+
+        Rules.configuration_error(
+          "Invalid configuration value for mutation.sampling.seed: expected Integer >= 0, got #{value.inspect}"
+        )
+      end
+
       def validate_sampling_completeness(value)
         return if value.key?(:ratio) && value.key?(:strategy)
 

data/lib/henitai/configuration_validator.rb

@@ -26,9 +26,10 @@ module Henitai
     ].freeze
     VALID_MUTATION_KEYS = %i[
       operators timeout timeout_multiplier ignore_patterns max_flaky_retries max_log_bytes max_timeout sampling
+      control_runs flaky_detection fork_server
     ].freeze
     VALID_REPORTS_KEYS = %i[checkpoint checkpoint_every checkpoint_interval].freeze
-    VALID_SAMPLING_KEYS = %i[ratio strategy].freeze
+    VALID_SAMPLING_KEYS = %i[ratio strategy seed].freeze
     VALID_COVERAGE_CRITERIA_KEYS = %i[test_result timeout process_abort].freeze
     VALID_THRESHOLDS_KEYS = %i[high low].freeze
     VALID_DASHBOARD_KEYS = %i[project base_url].freeze

data/lib/henitai/constant_path.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Names constants as the source writes them and attributes them to the
+  # namespace they belong to, as far as the source alone can tell.
+  module ConstantPath
+    module_function
+
+    # The constant path of a +const+ or +casgn+ node as written;
+    # root-qualified paths keep their leading +::+. nil for other nodes.
+    def of(node)
+      return unless node.respond_to?(:type)
+
+      case node.type
+      when :const, :casgn
+        parent = of(node.children[0])
+        own = node.children[1].to_s
+        parent.nil? ? own : "#{parent}::#{own}"
+      when :cbase
+        ""
+      end
+    end
+
+    # +name+ inside +namespace+. A root-qualified name (+::Top+) ignores the
+    # enclosing namespace.
+    def qualify(namespace, name)
+      return name.delete_prefix("::") if name&.start_with?("::")
+      return name if namespace.nil? || namespace.empty?
+      return namespace if name.nil? || name.empty?
+
+      "#{namespace}::#{name}"
+    end
+
+    # The object a singleton method or singleton class is defined on: the
+    # enclosing namespace for +self+, the named constant otherwise, nil for
+    # any other object. A relative constant is attributed to the innermost
+    # lexical candidate, which Ruby also tries first. The source alone cannot
+    # tell whether +Other+ inside +module Outer+ is +Outer::Other+ or
+    # +::Other+, so this name can be off; activation resolves the real object
+    # at runtime (Mutant::Activator).
+    def owner(receiver, namespace)
+      case receiver.type
+      when :self then namespace
+      when :const then qualify(namespace, of(receiver))
+      end
+    end
+  end
+end

data/lib/henitai/control_run.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Verifies, after execution, that the activation path itself does not break
+  # a subject's tests.
+  #
+  # For every subject with a detected verdict (Killed, Timeout, RuntimeError)
+  # the unmutated method is injected through the same activation and fork
+  # path, against the same test files. The tests must pass. If they do not,
+  # injecting the method is what made them fail -- a lost constant scope,
+  # `super` or `yield` inside `define_method`, a rebuilt parameter list -- so
+  # none of that subject's detections can be credited to its mutations. They
+  # are reclassified as CompileError with the control's outcome as reason.
+  #
+  # Verdicts reused from history are left alone: they were not produced by
+  # this run's activation.
+  class ControlRun
+    DETECTED = %i[killed timeout runtime_error].freeze
+
+    # @param timeout_for [#call] test files -> timeout in seconds
+    def initialize(integration:, timeout_for:)
+      @integration = integration
+      @timeout_for = timeout_for
+    end
+
+    # @return [Hash] verified:, failed: subjects; reclassified: mutants
+    def verify(mutants)
+      stats = { verified: 0, failed: 0, reclassified: 0 }
+      detected_groups(mutants).each_value do |detected|
+        stats[:verified] += 1
+        result = run_control(detected.first)
+        next if result.status == :survived
+
+        stats[:failed] += 1
+        stats[:reclassified] += reclassify(detected, result)
+      end
+      stats
+    end
+
+    private
+
+    def detected_groups(mutants)
+      Array(mutants)
+        .select { |mutant| DETECTED.include?(mutant.status) && !mutant.from_cache? && mutant.original_node }
+        .group_by { |mutant| [mutant.subject, test_files(mutant)] }
+    end
+
+    def run_control(mutant)
+      files = test_files(mutant)
+      @integration.run_mutant(mutant: control_for(mutant), test_files: files, timeout: @timeout_for.call(files))
+    end
+
+    def control_for(mutant)
+      node = mutant.original_node
+      Mutant.new(subject: mutant.subject, operator: "Control", nodes: { original: node, mutated: node },
+                 description: "unmutated control", location: mutant.location)
+    end
+
+    def reclassify(detected, result)
+      reason = "control run failed: the unmutated method fails its tests when injected " \
+               "(#{[result.status, result.status_reason].compact.join(': ')})"
+      detected.each do |mutant|
+        mutant.status = :compile_error
+        mutant.status_reason = reason
+      end
+      detected.size
+    end
+
+    def test_files(mutant)
+      Array(mutant.covered_by).sort
+    end
+  end
+end

data/lib/henitai/coverage_bootstrapper.rb

@@ -45,7 +45,9 @@ module Henitai
       # but irrelevant report (e.g. from a different working directory) must
       # still trigger a re-bootstrap rather than silently proceeding with no
       # usable coverage.
-      unless coverage_ready?(source_files, config, integration, resolved_test_files)
+      if flaky_detection?(config)
+        run_flaky_baseline(integration, config, resolved_test_files)
+      elsif !coverage_ready?(source_files, config, integration, resolved_test_files)
         bootstrap_coverage(integration, config, resolved_test_files)
       end
 
@@ -69,7 +71,25 @@ module Henitai
     def coverage_ready?(source_files, config, integration, test_files)
       coverage_fresh?(source_files, config, test_files) &&
         coverage_available?(source_files, config) &&
-        per_test_coverage_ready?(source_files, config, integration, test_files)
+        per_test_coverage_ready?(source_files, config, integration, test_files) &&
+        boot_seconds_ready?(config, integration)
+    end
+
+    # Timeout calibration reads the boot time the per-test collector writes
+    # next to the coverage artifacts, so a missing boot file means the
+    # baseline must run again to measure it.
+    def boot_seconds_ready?(config, integration)
+      return true unless calibration_enabled?(config) && per_test_coverage_supported?(integration)
+
+      File.exist?(boot_seconds_report_path(config))
+    end
+
+    def calibration_enabled?(config)
+      config.respond_to?(:timeout_configured?) && !config.timeout_configured?
+    end
+
+    def boot_seconds_report_path(config)
+      File.join(reports_dir(config), PerTestCoverageCollector::BOOT_FILE_NAME)
     end
 
     def covered_source_files(source_files, coverage_lines)
@@ -135,19 +155,25 @@ module Henitai
             return
           end
 
-          raise CoverageError, build_bootstrap_error(result)
+          raise CoverageError, BootstrapErrorMessage.build(result)
         end
       end
     end
 
-    def build_bootstrap_error(result)
-      return "Configured test suite failed while generating coverage" unless result.respond_to?(:log_path)
+    # Flaky detection needs two complete baseline runs, so the existing
+    # coverage is never reused in this mode.
+    def flaky_detection?(config)
+      config.respond_to?(:flaky_detection) && config.flaky_detection
+    end
 
-      tail = result.tail(12).strip
-      message = +"Configured test suite failed while generating coverage"
-      message << " (see #{result.log_path})"
-      message << "\n#{tail}" unless tail.empty?
-      message
+    def run_flaky_baseline(integration, config, test_files)
+      with_reports_dir(config) do
+        with_coverage_dir(config) do
+          FlakyDetectionBaseline.new(reports_dir: reports_dir(config))
+                                .run(integration:, test_files:)
+          record_dependency_manifest(config)
+        end
+      end
     end
 
     def with_coverage_dir(config)

data/lib/henitai/coverage_formatter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "henitai/per_test_coverage_collector"
+require "henitai/test_file_outcomes"
+require "henitai/rspec_outcomes"
 
 module Henitai
   # Collects per-test coverage data for static filtering heuristics.
@@ -8,8 +10,14 @@ module Henitai
     REPORT_DIR_ENV = PerTestCoverageCollector::REPORT_DIR_ENV
     REPORT_FILE_NAME = PerTestCoverageCollector::REPORT_FILE_NAME
 
-    def initialize(_output)
-      @collector = PerTestCoverageCollector.new
+    def initialize(_output, boot_clock: SuiteBootClock.from_env(ENV))
+      @collector = PerTestCoverageCollector.new(boot_clock:)
+      @outcomes = TestFileOutcomes.new
+      @outcome_listener = RspecOutcomes::Listener.new(@outcomes)
+    end
+
+    def example_started(_notification)
+      @collector.test_started
     end
 
     def example_finished(notification)
@@ -18,10 +26,25 @@ module Henitai
         example.metadata[:file_path],
         duration: example.execution_result.run_time
       )
+      @outcome_listener.example_finished(notification)
+    end
+
+    def example_group_started(notification)
+      @outcome_listener.example_group_started(notification)
+    end
+
+    def example_group_finished(notification)
+      @outcome_listener.example_group_finished(notification)
+    end
+
+    def message(notification)
+      @outcome_listener.message(notification)
     end
 
-    def dump_summary(_summary)
+    def dump_summary(summary)
+      @outcome_listener.dump_summary(summary)
       @collector.write_report
+      @outcomes.write(TestFileOutcomes.default_report_path)
     end
   end
 end

data/lib/henitai/coverage_report_reader.rb

@@ -7,6 +7,7 @@ module Henitai
   class CoverageReportReader
     DEFAULT_COVERAGE_REPORT_PATH = "coverage/.resultset.json"
     DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = "coverage/henitai_per_test.json"
+    DEFAULT_SUITE_BOOT_REPORT_PATH = "coverage/henitai_suite_boot.json"
 
     def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)
       return {} unless File.exist?(path)
@@ -37,6 +38,26 @@ module Henitai
       end.to_h
     end
 
+    # Suite boot seconds (loading helpers, spec files and before(:suite)).
+    # Missing or malformed reports yield 0.0, the value for "unknown".
+    def boot_seconds(path = DEFAULT_SUITE_BOOT_REPORT_PATH)
+      return 0.0 unless File.exist?(path)
+
+      parsed = JSON.parse(File.read(path))
+      parsed.is_a?(Hash) ? usable_boot_seconds(parsed["boot_seconds"]) : 0.0
+    rescue JSON::ParserError, ArgumentError, TypeError
+      0.0
+    end
+
+    # Only a finite, non-negative number is a usable measurement; anything
+    # else is treated as unknown.
+    def usable_boot_seconds(value)
+      return 0.0 unless value.is_a?(Numeric)
+
+      seconds = Float(value)
+      seconds.finite? && seconds >= 0 ? seconds : 0.0
+    end
+
     private
 
     def per_test_report(path)

data/lib/henitai/equivalence_detector/operand_predicates.rb

@@ -27,8 +27,24 @@ module Henitai
       # Multiplicative identity: `x * 1`, `x / 1` and `x ** 1` all reduce to `x`.
       def one_operand?(node) = numeric_operand?(node, 1)
 
+      # The identities above only hold when the receiver is a number. For an
+      # unknown receiver `"ab" * 1` is `"ab"` while `"ab" / 1` raises, and a
+      # custom object may define its own operators. Negative zero is excluded
+      # because `-0.0 + 0` is `0.0` while `-0.0 - 0` is `-0.0`.
+      def numeric_receiver?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :int then true
+        when :float then !negative_zero?(node.children.first)
+        else false
+        end
+      end
+
       private
 
+      def negative_zero?(value) = value.zero? && (1.0 / value).negative?
+
       # Reads the right-hand operand of a binary send. Guards against a
       # malformed node whose operand is a bare Ruby value rather than an AST
       # node -- that shape does not occur in parsed source, but the detector

data/lib/henitai/equivalence_detector.rb

@@ -6,9 +6,25 @@ require_relative "equivalence_detector/operand_predicates"
 module Henitai
   # Detects obvious equivalent mutants before execution.
   #
-  # The detector is intentionally conservative: it only marks mutations as
-  # equivalent when the AST shape and the operand literals make the equivalence
-  # obvious enough to be useful.
+  # The detector is intentionally conservative: it only marks a mutation as
+  # equivalent when the AST shape and the literal operands prove the
+  # equivalence for every runtime value. Each rule below states the argument
+  # that makes it sound; a rule that cannot state one is not implemented.
+  #
+  # Rules:
+  #   * Additive identity, `n + 0` <-> `n - 0`, when `n` is an Integer literal
+  #     or a non-negative-zero Float literal. Both return `n`.
+  #   * Multiplicative identity, `n * 1` <-> `n / 1` <-> `n ** 1`, under the
+  #     same receiver condition. Both return `n`.
+  #   * Left-literal logical identity, `false || x` -> `x` and `true && x` -> `x`.
+  #     `false || x` is `x` for every `x`, and `true && x` is `x` for every `x`.
+  #     The right-literal forms are unsound: `nil || false` is `false` and
+  #     `5 && true` is `true`.
+  #   * Singleton equality, `s == v` <-> `s.equal?(v)` when `s` and `v` are
+  #     Symbol, nil, true or false literals. These values are unique instances,
+  #     so `==` reduces to identity.
+  #   * String equality, `"a" == "b"` <-> `"a".eql?("b")` when both operands are
+  #     String literals. Both compare type and value for two Strings.
   class EquivalenceDetector
     def analyze(mutant)
       return mutant unless equivalent_mutation?(mutant)
@@ -48,14 +64,16 @@ module Henitai
       additive_operator?(original.children[1]) &&
         additive_operator?(mutated.children[1]) &&
         zero_operand?(original) &&
-        zero_operand?(mutated)
+        zero_operand?(mutated) &&
+        numeric_receiver?(original)
     end
 
     def multiplicative_equivalent?(original, mutated)
       multiplicative_operator?(original.children[1]) &&
         multiplicative_operator?(mutated.children[1]) &&
         one_operand?(original) &&
-        one_operand?(mutated)
+        one_operand?(mutated) &&
+        numeric_receiver?(original)
     end
 
     def equivalent_logical_mutation?(mutant)
@@ -71,28 +89,23 @@ module Henitai
     end
 
     def logical_identity_equivalent?(original, mutated)
-      case original.type
-      when :or
+      if original.type == :or
         false_identity_equivalent?(original, mutated)
-      when :and
-        true_identity_equivalent?(original, mutated)
       else
-        false
+        true_identity_equivalent?(original, mutated)
       end
     end
 
+    # `false || x` is `x` for every `x`. The right-literal form `x || false` is
+    # not: `nil || false` is `false`, not `nil`.
     def false_identity_equivalent?(original, mutated)
-      return true if false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
-      return true if false_operand?(original.children[1]) && same_node?(mutated, original.children[0])
-
-      false
+      false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
     end
 
+    # `true && x` is `x` for every `x`. The right-literal form `x && true` is
+    # not: `5 && true` is `true`, not `5`.
     def true_identity_equivalent?(original, mutated)
-      return true if true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
-      return true if true_operand?(original.children[1]) && same_node?(mutated, original.children[0])
-
-      false
+      true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
     end
 
     def false_operand?(node)
@@ -121,6 +134,8 @@ module Henitai
 
     def one_operand?(node) = operand_predicates.one_operand?(node)
 
+    def numeric_receiver?(node) = operand_predicates.numeric_receiver?(node.children[0])
+
     def operand_predicates = @operand_predicates ||= OperandPredicates.new
 
     # Detects `lhs == <singleton>` mutated to `lhs.equal?(<singleton>)` (or the
@@ -146,28 +161,27 @@ module Henitai
         equality_operators?(original.children[1], mutated.children[1])
     end
 
-    # Detects `lhs == rhs` mutated to `lhs.eql?(rhs)` (or the reverse) when at
-    # least one operand is a string literal.
+    # Detects `lhs == rhs` mutated to `lhs.eql?(rhs)` (or the reverse) when both
+    # operands are string literals.
     #
-    # String#eql? is documented to compare both type and value. Since String#==
-    # also compares type and value (it returns false for any non-String argument
-    # without invoking the other object's #==), the two methods are equivalent
-    # for all possible inputs whenever at least one operand is statically known
-    # to be a String — proven here by the presence of a :str literal on the
-    # receiver or the argument side.
-    #
-    # When no operand is a string literal we conservatively leave the mutant
-    # pending: the receiver could be any object whose custom #== diverges from
-    # its #eql?.
+    # With two String literals, neither `==` nor `eql?` can reach a custom
+    # method, so both compare type and value and return the same result. A
+    # single string literal is not enough: an unknown receiver can override
+    # `==`, and `"a" == obj` calls `obj == "a"` when obj responds to `to_str`.
     def equivalent_string_eql_mutation?(mutant)
       original = mutant.original_node
       mutated  = mutant.mutated_node
 
+      string_eql_swap?(original, mutated) &&
+        string_literal?(original.children[0]) &&
+        string_literal?(original.children[2])
+    end
+
+    def string_eql_swap?(original, mutated)
       string_eql_send?(original) && string_eql_send?(mutated) &&
         same_receiver?(original, mutated) &&
         string_eql_operators?(original.children[1], mutated.children[1]) &&
-        same_rhs?(original, mutated) &&
-        string_operand?(original)
+        same_rhs?(original, mutated)
     end
 
     def string_eql_send?(node)
@@ -189,12 +203,6 @@ module Henitai
       same_node?(original.children[2], mutated.children[2])
     end
 
-    # Returns true when at least one operand is a string literal, giving static
-    # proof that the comparison is string-typed on at least one side.
-    def string_operand?(node)
-      string_literal?(node.children[0]) || string_literal?(node.children[2])
-    end
-
     def string_literal?(node)
       node.is_a?(Parser::AST::Node) && node.type == :str
     end

data/lib/henitai/example_summary.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Reads whether a test run's output says that no example ran.
+  #
+  # Both texts are matched at the start of a line only, and only the last
+  # summary line counts: failure output may quote either text, indented, from
+  # the test source, and the tests themselves may print summaries of nested
+  # runs before the run's own.
+  module ExampleSummary
+    NO_EXAMPLES_FOUND = /^No examples found\.$/
+    SUMMARY = /^(\d+) (?:examples?, \d+ failures?|runs?, \d+ assertions?)/
+
+    module_function
+
+    def none_ran?(output)
+      text = output.to_s
+      summaries = text.scan(SUMMARY)
+      return NO_EXAMPLES_FOUND.match?(text) if summaries.empty?
+
+      summaries.last == ["0"]
+    end
+  end
+end