henitai 0.5.3 → 0.6.0

data/lib/henitai/integration/capped_log_sink.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Writes captured child output to a log file up to a byte cap, then
+    # discards the overflow and leaves a single truncation marker behind.
+    # Not interrupt-safe: the drain thread must be stopped cooperatively,
+    # never killed mid-write.
+    class CappedLogSink
+      def initialize(file, cap)
+        @file = file
+        @cap = cap
+        @written = 0
+        @truncated = false
+      end
+
+      def write(chunk)
+        return unless @written < @cap
+
+        slice = chunk.byteslice(0, @cap - @written)
+        @file.write(slice)
+        @written += slice.bytesize
+        write_truncation_marker if @written >= @cap && !@truncated
+      end
+
+      private
+
+      def write_truncation_marker
+        @file.write("\n[henitai] output truncated at #{@cap} bytes\n")
+        @truncated = true
+      end
+    end
+  end
+end

data/lib/henitai/integration/child_bootstrap.rb

@@ -9,6 +9,12 @@ module Henitai
     # without forking, and so both the RSpec and Minitest paths -- which share
     # MutantRunSupport#spawn_mutant -- get identical treatment.
     module ChildBootstrap
+      # Signals the parent traps for its own shutdown (INT/TERM/HUP) and for
+      # its event-loop wakeup (CHLD). A child that kept those handlers would
+      # ignore the SIGTERM sent while draining it and could write into the
+      # parent's wakeup pipe.
+      INHERITED_TRAPS = %w[INT TERM HUP CHLD].freeze
+
       # @param parent_pid [Integer] captured in the parent *before* Process.fork.
       #   Reading Process.ppid here instead would race the very death the
       #   watchdog is looking for: a parent that dies between fork and this
@@ -18,6 +24,7 @@ module Henitai
         # First, so that even a crash later in this method releases the
         # reports-directory lock rather than pinning it with an inherited fd.
         InheritedFdRegistry.close_all!
+        INHERITED_TRAPS.each { |signal| Signal.trap(signal, "DEFAULT") }
         Process.setpgid(0, 0)
         OrphanWatchdog.start(parent_pid:)
         nil

data/lib/henitai/integration/child_report_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Henitai
+  module Integration
+    # Carries a mutant child's report to the parent through a small JSON file
+    # next to the child's logs. The parent clears the file before each fork so
+    # a retry can never read the previous attempt's report.
+    class ChildReportStore
+      def write(path, data)
+        return unless path
+
+        FileUtils.mkdir_p(File.dirname(path))
+        temp_path = "#{path}.#{Process.pid}.tmp"
+        File.write(temp_path, JSON.generate(data))
+        File.rename(temp_path, path)
+        nil
+      end
+
+      def read(path)
+        return unless path && File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def clear(path)
+        FileUtils.rm_f(path) if path
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest.rb

@@ -5,6 +5,7 @@ require "fileutils"
 # tail, by which point Base is already defined, so the require is skipped.
 require_relative "../integration" unless defined?(Henitai::Integration::Base)
 require_relative "minitest_load_path"
+require_relative "minitest_preload"
 require_relative "minitest_suite_command"
 require_relative "minitest_test_runner"
 require_relative "rails_environment_preloader"
@@ -18,6 +19,7 @@ module Henitai
     # but implements its own Minitest-specific test invocation and suite command.
     # Per-test coverage collection is not yet wired into this path.
     class Minitest < Base
+      include MinitestPreload
       include MutantRunSupport
       include RspecTestSelection
 
@@ -60,8 +62,8 @@ module Henitai
 
       private
 
-      def run_tests(test_files)
-        MinitestTestRunner.new.call(test_files)
+      def run_tests(test_files, outcomes, &)
+        MinitestTestRunner.new(preloaded: @minitest_preloaded == true).call(test_files, outcomes, &)
       end
 
       def subprocess_env
@@ -81,7 +83,7 @@ module Henitai
         File.open(log_paths[:stdout_path], "w") do |stdout_file|
           File.open(log_paths[:stderr_path], "w") do |stderr_file|
             Process.spawn(
-              subprocess_env,
+              suite_process_env,
               *suite_command(test_files),
               out: stdout_file,
               err: stderr_file,
@@ -101,8 +103,8 @@ module Henitai
       end
 
       def spec_files
-        (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
-          .reject { |f| f.start_with?("test/system/") }
+        @spec_files ||= (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
+                        .reject { |f| f.start_with?("test/system/") }
       end
     end
   end

data/lib/henitai/integration/minitest_autorun.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Turns Minitest.autorun into a no-op, so that requiring test files never
+    # registers the at_exit hook that would run the suite a second time.
+    module MinitestAutorun
+      SUPPRESSOR = Module.new { def autorun = nil }
+
+      def self.suppress!
+        require "minitest"
+        singleton_class = ::Minitest.singleton_class
+        singleton_class.prepend(SUPPRESSOR) unless singleton_class.ancestors.include?(SUPPRESSOR)
+        nil
+      rescue LoadError, NameError
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_outcome_reporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "henitai/test_file_outcomes"
+require "henitai/minitest_result_file"
+
+module Henitai
+  module Integration
+    # Records the outcome of each finished Minitest result per test file.
+    class MinitestOutcomeReporter < ::Minitest::Reporter
+      def initialize(outcomes, report_path: nil, io: $stdout)
+        super(io, {})
+        @outcomes = outcomes
+        @report_path = report_path
+      end
+
+      def record(result)
+        super
+        MinitestResultFile.record(@outcomes, result)
+      end
+
+      def report
+        super
+        @outcomes.write(@report_path) if @report_path
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_preload.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "minitest_autorun"
+require_relative "minitest_load_path"
+require_relative "rails_environment_preloader"
+
+module Henitai
+  module Integration
+    # Fork-server support for the Minitest integration (ADR-15): the server
+    # loads the environment and the union of the run's test files once, without
+    # running anything; each mutant process then runs only its own files.
+    module MinitestPreload
+      def fork_server_supported?
+        true
+      end
+
+      def preload_environment(test_files)
+        MinitestAutorun.suppress!
+        CoverageRuntimeSuppressors.suppress_simplecov!
+        CoverageRuntimeSuppressors.suppress_coverage!
+        subprocess_env.each { |key, value| ENV[key] = value }
+        MinitestLoadPath.ensure!
+        RailsEnvironmentPreloader.new.call
+        test_files.each { |file| require File.expand_path(file) }
+        @minitest_preloaded = true
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_runnable_filter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "henitai/minitest_result_file"
+
+module Henitai
+  module Integration
+    # Narrows Minitest's registry of test classes to those defined in the given
+    # test files, for a process that inherited the union of a run's test files
+    # from the fork server (ADR-15). A class belongs to a file when one of its
+    # test methods is defined there.
+    class MinitestRunnableFilter
+      def initialize(test_files)
+        @wanted = test_files.to_set { |file| canonical(file) }
+      end
+
+      def apply!
+        with_seed { ::Minitest::Runnable.runnables.select! { |suite| defined_in_wanted_file?(suite) } }
+      end
+
+      private
+
+      # runnable_methods shuffles with Minitest.seed, which is unset before a run.
+      def with_seed
+        original = ::Minitest.seed
+        ::Minitest.seed ||= 0
+        yield
+      ensure
+        ::Minitest.seed = original
+      end
+
+      # A suite belongs to a file when its class is defined there, or when one
+      # of its test methods is. The class file covers tests inherited from a
+      # shared module, which report the module's file; the method check covers
+      # a class reopened in another file.
+      def defined_in_wanted_file?(suite)
+        wanted_class_file?(suite) || method_in_wanted_file?(suite)
+      rescue NotImplementedError, NameError
+        false
+      end
+
+      def wanted_class_file?(suite)
+        file = suite.name && MinitestResultFile.class_file_of(suite.name)
+        !file.nil? && @wanted.include?(canonical(file))
+      end
+
+      def method_in_wanted_file?(suite)
+        suite.runnable_methods.any? do |name|
+          location = suite.instance_method(name).source_location
+          location && @wanted.include?(canonical(location.first))
+        end
+      end
+
+      # Symlinked temp or checkout directories must not make one file two paths.
+      def canonical(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_test_runner.rb

@@ -1,16 +1,32 @@
 # frozen_string_literal: true
 
-require_relative "coverage_suppression"
+require "henitai/integration/minitest_autorun"
+require "henitai/integration/minitest_outcome_reporter"
+require "henitai/integration/minitest_runnable_filter"
+require "henitai/test_file_outcomes"
 
 module Henitai
   module Integration
     # Runs Minitest test files in-process and normalizes the result to an
     # exit code, for Minitest#run_tests during a single mutant activation.
     class MinitestTestRunner
-      def call(test_files)
-        CoverageRuntimeSuppressors.suppress_simplecov!
-        suppress_autorun!
-        test_files.each { |file| require File.expand_path(file) }
+      PLUGIN_NAME = "henitai_outcomes"
+
+      # +preloaded+: the fork server already required the union of the run's
+      # test files, so only the ones requested here are kept to run.
+      def initialize(preloaded: false)
+        @preloaded = preloaded
+      end
+
+      # Yields once the test files are required and before Minitest runs; a
+      # falsy block result skips the run. Per-file outcomes are recorded into
+      # +outcomes+ through a Minitest reporter plugin.
+      def call(test_files, outcomes = TestFileOutcomes.new, &after_load)
+        MinitestAutorun.suppress!
+        load_tests(test_files)
+        return 1 if after_load && !after_load.call
+
+        install_outcome_plugin(outcomes)
         # @type var empty_args: Array[String]
         empty_args = []
         status = ::Minitest.run(empty_args)
@@ -21,18 +37,19 @@ module Henitai
 
       private
 
-      def suppress_autorun!
-        require "minitest"
-        singleton_class = ::Minitest.singleton_class
-        suppressor = @autorun_suppressor ||= Module.new.tap do |mod|
-          mod.define_method(:autorun) { nil }
+      def install_outcome_plugin(outcomes)
+        ::Minitest.extensions << PLUGIN_NAME unless ::Minitest.extensions.include?(PLUGIN_NAME)
+        init = :"plugin_#{PLUGIN_NAME}_init"
+        ::Minitest.singleton_class.send(:remove_method, init) if ::Minitest.respond_to?(init)
+        ::Minitest.define_singleton_method(init) do |_options|
+          reporter.reporters << MinitestOutcomeReporter.new(outcomes)
         end
-        return if singleton_class.ancestors.include?(suppressor)
+      end
 
-        singleton_class.prepend(suppressor)
-        nil
-      rescue LoadError, NameError
-        nil
+      def load_tests(test_files)
+        return MinitestRunnableFilter.new(test_files).apply! if @preloaded
+
+        test_files.each { |file| require File.expand_path(file) }
       end
     end
   end

data/lib/henitai/integration/mutant_run_support.rb

@@ -10,8 +10,11 @@ module Henitai
     # The framework-specific test invocation is delegated to #run_tests, which
     # including classes must implement.
     module MutantRunSupport
+      # The previous attempt's report is cleared before the fork, so a retried
+      # child that dies early can never be classified by stale data.
       def spawn_mutant(mutant:, test_files:)
-        log_paths = scenario_log_paths(mutant_log_name(mutant))
+        log_paths = mutant_log_paths(mutant)
+        child_report_store.clear(log_paths[:report_path])
         RspecProcessRunner.new.spawn_mutant(self, mutant:, test_files:, log_paths:)
       end
 
@@ -29,17 +32,22 @@ module Henitai
         }
       end
 
+      # Mutant runs carry a report path and are classified from the child's
+      # report; the baseline suite has none and keeps exit-status semantics.
+      def mutant_log_paths(mutant)
+        log_paths = scenario_log_paths(mutant_log_name(mutant))
+        log_paths.merge(report_path: log_paths[:log_path].sub(/\.log\z/, ".report.json"))
+      end
+
       def build_result(wait_result, log_paths)
         stdout = scenario_log_support.read_log_file(log_paths[:stdout_path])
         stderr = scenario_log_support.read_log_file(log_paths[:stderr_path])
         scenario_log_support.write_combined_log(log_paths[:log_path], stdout, stderr)
+        output = { stdout:, stderr:, log_path: log_paths[:log_path] }
+        return ScenarioExecutionResult.build(wait_result:, **output) unless log_paths.key?(:report_path)
 
-        ScenarioExecutionResult.build(
-          wait_result:,
-          stdout:,
-          stderr:,
-          log_path: log_paths[:log_path]
-        )
+        report = child_report_store.read(log_paths[:report_path])
+        ScenarioExecutionResult.build_for_mutant(wait_result:, report:, **output)
       end
 
       def run_in_child(mutant:, test_files:, log_paths:)
@@ -61,17 +69,69 @@ module Henitai
       private
 
       def run_child_activation_and_tests(mutant:, test_files:, log_paths:)
+        report = ->(data) { child_report_store.write(log_paths[:report_path], data) }
         scenario_log_support.with_coverage_dir(mutant.id) do
           scenario_log_support.capture_child_output(log_paths) do
-            child_debug_log.mutant_meta(mutant)
-            child_debug_log.activation_start(mutant.id)
-            activation_result = Mutant::Activator.activate!(mutant)
-            child_debug_log.activation_check
-            child_debug_log.activation_end(activation_result, test_files:)
-            activation_result == :compile_error ? 2 : run_tests(test_files)
+            run_tests_in_child(mutant, test_files, report)
           end
         end
       end
+
+      # Any failure to put the mutant in place is a harness outcome: the tests
+      # never ran against the mutation, so nothing may count as a kill.
+      def activate_in_child(mutant, test_files, report)
+        return true unless activate_with_debug_log(mutant, test_files) == :compile_error
+
+        report.call("outcome" => "activation_failed", "reason" => "the activation source does not compile")
+        false
+      rescue StandardError, ScriptError => e
+        warn "henitai: mutant activation failed: #{e.class}: #{e.message}"
+        report.call("outcome" => "activation_failed", "reason" => "#{e.class}: #{e.message}")
+        false
+      end
+
+      def activate_with_debug_log(mutant, test_files)
+        log = child_debug_log
+        log.mutant_meta(mutant)
+        log.activation_start(mutant.id)
+        activation_result = Mutant::Activator.activate!(mutant)
+        log.activation_check
+        log.activation_end(activation_result, test_files:)
+        activation_result
+      end
+
+      # RSpec and Minitest let SystemExit through by design. Raised by the
+      # code under test it ends the run midway, so it is reported instead of
+      # becoming the child's exit status.
+      #
+      # The mutant is activated from #run_tests' after-load hook: once the test
+      # files (and the code they require) are loaded, before any test runs.
+      # Activating earlier would load the subject file on its own, without the
+      # superclasses and constants the rest of the application defines.
+      def run_tests_in_child(mutant, test_files, report)
+        activated = nil
+        outcomes = TestFileOutcomes.new
+        exit_code = run_tests(test_files, outcomes) { activated = activate_in_child(mutant, test_files, report) }
+        return finish_without_tests(activated, report) unless activated
+
+        report.call(
+          "outcome" => "tests_finished",
+          "exit_code" => exit_code,
+          "failed_tests" => outcomes.failed_files,
+          "unattributed_failures" => outcomes.unattributed_failures?
+        )
+        exit_code
+      rescue SystemExit => e
+        report.call("outcome" => "system_exit", "status" => e.status)
+        1
+      end
+
+      # A nil activation means the hook never ran: the test files failed to
+      # load, before the mutant was in place.
+      def finish_without_tests(activated, report)
+        report.call("outcome" => "environment_failed") if activated.nil?
+        2
+      end
     end
   end
 end

data/lib/henitai/integration/rspec_child_runner.rb

@@ -8,7 +8,20 @@ module Henitai
     module RspecChildRunner
       private
 
-      def run_rspec_runner(test_files)
+      def run_rspec_runner(test_files, &after_load)
+        log = child_debug_log
+        runner = @preloaded_runner || prepare_rspec_runner(test_files)
+        return 1 unless ready_to_run?(after_load)
+
+        run_rspec_specs(runner, example_groups_to_run(test_files))
+      rescue SystemExit => e
+        log.write("[henitai-debug-child] runner_run_system_exit status=#{e.status.inspect}")
+        raise
+      ensure
+        child_debug_log.write("[henitai-debug-child] runner_run_ensure")
+      end
+
+      def prepare_rspec_runner(test_files)
         log = child_debug_log
         log.write("[henitai-debug-child] build_rspec_runner_start")
         runner = build_rspec_runner
@@ -17,12 +30,34 @@ module Henitai
         configure_rspec_runner(runner)
         log.write("[henitai-debug-child] configure_rspec_runner_return")
         load_rspec_spec_files(test_files)
-        run_rspec_specs(runner)
-      rescue SystemExit => e
-        log.write("[henitai-debug-child] runner_run_system_exit status=#{e.status.inspect}")
-        raise
-      ensure
-        child_debug_log.write("[henitai-debug-child] runner_run_ensure")
+        runner
+      end
+
+      # A fork-server process loaded the union of the run's spec files; each
+      # mutant process runs only the groups defined in its own files.
+      def example_groups_to_run(test_files)
+        groups = ::RSpec.world.ordered_example_groups
+        return groups unless @preloaded_runner
+
+        wanted = test_files.map { |file| File.expand_path(file) }
+        groups.select { |group| wanted.include?(example_group_file(group)) }
+      end
+
+      def example_group_file(group)
+        metadata = group.metadata
+        metadata[:absolute_file_path] || File.expand_path(metadata[:file_path])
+      end
+
+      # The after-load hook (mutant activation) runs only when every spec file
+      # loaded; a falsy hook result also skips the run.
+      def ready_to_run?(after_load)
+        rspec_loaded_cleanly? && (after_load.nil? || after_load.call)
+      end
+
+      # RSpec records a spec file that failed to load and quits before running.
+      def rspec_loaded_cleanly?
+        world = ::RSpec.world
+        !(world.wants_to_quit || world.rspec_is_quitting)
       end
 
       def build_rspec_runner
@@ -51,9 +86,9 @@ module Henitai
         child_debug_log.write("[henitai-debug-child] load_spec_files_return")
       end
 
-      def run_rspec_specs(runner)
+      def run_rspec_specs(runner, example_groups)
         child_debug_log.write("[henitai-debug-child] run_specs_start")
-        result = runner.send(:run_specs, ::RSpec.world.ordered_example_groups)
+        result = runner.send(:run_specs, example_groups)
         child_debug_log.write("[henitai-debug-child] run_specs_return result=#{result.inspect}")
         result
       end

data/lib/henitai/integration/rspec_preload.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Lets the fork server (ADR-15) boot the RSpec environment once. The
+    # booted runner stays in the server; every forked mutant process then runs
+    # its own subset of the loaded example groups.
+    module RspecPreload
+      class PreloadError < StandardError; end
+
+      def fork_server_supported?
+        true
+      end
+
+      # Loads RSpec, its configured requires (spec_helper, rails_helper, ...)
+      # and the given spec files, without activating a mutant or running a
+      # test. Coverage startup is suppressed before anything loads, as it is
+      # in every mutant child.
+      #
+      # @raise [PreloadError] when a spec file failed to load
+      def preload_environment(test_files)
+        CoverageRuntimeSuppressors.suppress_simplecov!
+        CoverageRuntimeSuppressors.suppress_coverage!
+        subprocess_env.each { |key, value| ENV[key] = value }
+        require "rspec/core"
+        ::RSpec.configuration.fail_if_no_examples = true
+        runner = prepare_rspec_runner(test_files)
+        raise PreloadError, "the spec files failed to load" unless rspec_loaded_cleanly?
+
+        @preloaded_runner = runner
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/rspec_process_runner.rb

@@ -52,7 +52,10 @@ module Henitai
     end
 
     # Captures the PID and log paths for a spawned mutant child process.
-    ChildHandle = Struct.new(:pid, :log_paths)
+    # +timeout+ is set only when the spawner knows better than the scheduler's
+    # resolver how long this child may run (a fallback child that boots the
+    # suite itself while the fork server is active).
+    ChildHandle = Struct.new(:pid, :log_paths, :timeout)
 
     # Runs RSpec child and suite processes on behalf of the integration.
     class RspecProcessRunner

data/lib/henitai/integration/scenario_log_support.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "capped_log_sink"
 
 module Henitai
   module Integration
@@ -12,6 +13,9 @@ module Henitai
       MAX_LOG_BYTES_ENV = "HENITAI_MAX_LOG_BYTES"
       DEFAULT_MAX_LOG_BYTES = 5_000_000
       DRAIN_CHUNK_BYTES = 65_536
+      # Bound on the reads of the final drain, so a grandchild that keeps
+      # writing cannot hold the close up.
+      DRAIN_AVAILABLE_READS = 16
 
       def capture_child_output(log_paths)
         output_files = open_child_output(log_paths)
@@ -69,37 +73,46 @@ module Henitai
         file = File.new(path, "wb")
         file.sync = true
         reader, writer = IO.pipe
-        thread = Thread.new { drain_capped(reader, file, cap) }
-        { file:, reader:, writer:, thread: }
-      end
-
-      def drain_capped(reader, file, cap)
-        written = 0
-        truncated = false
+        sink = CappedLogSink.new(file, cap)
+        stop_reader, stop_writer = IO.pipe
+        thread = Thread.new { drain_capped(reader, stop_reader, sink) }
+        { file:, reader:, writer:, stop_reader:, stop_writer:, thread: }
+      end
+
+      # Drains until EOF or until +stop_reader+ becomes readable. Never killed:
+      # the stop signal ends it cooperatively between sink writes.
+      # Uses Kernel#select rather than IO.select: the drain runs beside the
+      # tests under mutation, and specs that stub or count IO.select must not
+      # see the harness's own waits.
+      def drain_capped(reader, stop_reader, sink)
         loop do
-          chunk = reader.readpartial(DRAIN_CHUNK_BYTES)
-          next unless written < cap
-
-          slice = chunk.byteslice(0, cap - written)
-          file.write(slice)
-          written += slice.bytesize
-          next unless written >= cap && !truncated
+          ready, = select([reader, stop_reader])
+          break drain_available(reader, sink) if ready.include?(stop_reader)
 
-          file.write("\n[henitai] output truncated at #{cap} bytes\n")
-          truncated = true
+          sink.write(reader.readpartial(DRAIN_CHUNK_BYTES))
         end
       rescue IOError
         # EOFError (a subclass) on writer close, or a closed pipe: draining done.
         nil
       end
 
+      # Closing the writer lets the drain thread reach EOF. A grandchild may
+      # still hold a copy of the writer, so EOF is not awaited: the stop pipe
+      # makes the thread take what is readable right now and exit.
       def finish_capped_stream(stream)
         return unless stream
 
         stream[:writer].close
+        stream[:stop_writer].close
         stream[:thread].join
-        stream[:reader].close
-        stream[:file].close
+        %i[reader stop_reader file].each { |key| stream[key].close }
+      end
+
+      def drain_available(reader, sink)
+        DRAIN_AVAILABLE_READS.times { sink.write(reader.read_nonblock(DRAIN_CHUNK_BYTES)) }
+      rescue IO::WaitReadable, IOError
+        # Nothing more buffered right now, or the pipe is closed.
+        nil
       end
 
       def redirect_child_output(output_files)