ceedling 1.1.9 → 1.2.0

data/lib/ceedling/test_invoker/test_file_preprocessinator.rb

@@ -0,0 +1,148 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+require 'ceedling/test_context_extractor'
+require 'ceedling/test_invoker/test_pipeline_helpers'
+
+# Stage 11: each test file, preprocessed for the steps after it. The preprocessed file is
+# the runner's input, from which stage 12 parses test case names, and its
+# TEST_SOURCE_FILE() directives are scanned once it is written.
+#
+# When the preprocessed file is already current, its directives are recalled from a
+# small cache instead of being scanned again. That cache is an output of the
+# preprocessed target, so a damaged cache makes the target stale.
+#
+# The preprocessed file comes from a full expansion that reads every header the test
+# reaches, so the project files that expansion entered are registered as its
+# dependencies, as a compile registers its .d file. Editing a header that enables a test
+# case then reruns this stage and, through the runner's own dependencies, stage 13.
+class TestFilePreprocessinator
+
+  include TestPipelineHelpers
+
+  constructor(
+    :configurator,
+    :loginator,
+    :reportinator,
+    :batchinator,
+    :preprocessinator,
+    :test_context_extractor,
+    :file_path_utils,
+    :file_wrapper,
+    :dependinator,
+    :test_source_file_directive_resolver
+  )
+
+  def setup()
+    @context_extractor = @test_context_extractor
+  end
+
+  def preprocess(state)
+    skipped = 0
+
+    @batchinator.exec( workload: :compile, things: state.testables ) do |_, testable|
+      stale = preprocess_test_file( state, testable )
+      state.lock.synchronize { skipped += 1 } unless stale
+
+      stale ? scan_source_directives( testable ) : recall_source_directives( testable )
+      state.testables.each_value { |each| @test_source_file_directive_resolver.validate!( test: testable.name, filepath: each.filepath ) }
+    end
+
+    log_skip_summary( task: "test file preprocessing", count: skipped, noun: "test files" )
+  end
+
+  private
+
+  # The preprocessed path is deterministic, so it can be registered and checked before
+  # deciding whether to preprocess. Gives whether the test file was preprocessed.
+  def preprocess_test_file(state, testable)
+    target = target( testable )
+    @dependinator.register( target, files: [testable.filepath], meta: preprocess_meta( testable ) )
+    register_preprocessed_dependencies( target, expansion( testable ) ) if @file_wrapper.exist?( expansion( testable ) )
+    stale = @dependinator.stale?( target )
+
+    input = stale ? preprocess_now( testable ) : recall( testable, target )
+    state.lock.synchronize { testable.runner.input_filepath = input }
+
+    return stale
+  end
+
+  def target(testable)
+    return @file_path_utils.form_preprocessed_file_filepath( testable.filepath, testable.name )
+  end
+
+  def expansion(testable)
+    return @file_path_utils.form_preprocessed_file_full_expansion_filepath( testable.filepath, testable.name )
+  end
+
+  def preprocess_meta(testable)
+    return dependency_meta( flags: testable.preprocess_flags, defines: testable.preprocess_defines, search_paths: testable.search_paths )
+  end
+
+  def preprocess_now(testable)
+    return @preprocessinator.preprocess_test_file(
+      test: testable.name, filepath: testable.filepath, directives_only_filepath: directives_only_filepath( testable ),
+      fallback: fallback?( testable ), includes: @context_extractor.lookup_all_header_includes_list( testable.filepath ),
+      flags: testable.preprocess_flags, include_paths: testable.search_paths, vendor_paths: vendor_search_paths(),
+      defines: testable.preprocess_defines
+    )
+  end
+
+  def recall(testable, target)
+    log_module_progress( 'Skipping test file preprocessing for', testable, Verbosity::OBNOXIOUS )
+    return target
+  end
+
+  def directives_only_filepath(testable)
+    return testable.preprocess[:directives_only][:filepath]
+  end
+
+  def fallback?(testable)
+    return directives_only_fallback?( @configurator.test_build_preprocess_directives_only_available, directives_only_filepath( testable ) )
+  end
+
+  def source_files_cache(testable)
+    return @file_path_utils.form_preprocessed_source_files_cache_filepath( testable.filepath, testable.name )
+  end
+
+  # The cache is recalled whenever the preprocessed file is fresh, so that file vouches
+  # for it. Marking fresh only once the cache is written leaves the target stale if
+  # directive parsing raises.
+  def scan_source_directives(testable)
+    filename = File.basename( testable.filepath )
+    @loginator.log( @reportinator.generate_progress( "Parsing #{filename} for test source directive macros" ) )
+
+    @context_extractor.collect_simple_context_from_file( directives_source( testable ), testable.filepath, TestContextExtractor::Context::BUILD_DIRECTIVE_SOURCE_FILES )
+    @context_extractor.store_build_directives_cache( filepath: testable.filepath, cache_filepath: source_files_cache( testable ) )
+
+    mark_fresh( testable )
+  end
+
+  # The preprocessed file vouches for the directive cache and depends on what its
+  # expansion read
+  def mark_fresh(testable)
+    @dependinator.register( target( testable ), outputs: [source_files_cache( testable )] )
+    register_preprocessed_dependencies( target( testable ), expansion( testable ) )
+    @dependinator.mark_fresh( target( testable ) )
+  end
+
+  # Directives are scanned from the compacted directives-only output, or from the test
+  # file itself without one
+  def directives_source(testable)
+    return testable.filepath if fallback?( testable )
+
+    return @file_path_utils.form_preprocessed_file_compacted_directives_only_filepath( testable.filepath, testable.name )
+  end
+
+  def recall_source_directives(testable)
+    filename = File.basename( testable.filepath )
+    @loginator.log( @reportinator.generate_progress( "Recalling cached source directive macros for #{filename}" ), Verbosity::OBNOXIOUS )
+    @context_extractor.load_build_directives_cache( filepath: testable.filepath, cache_filepath: source_files_cache( testable ) )
+  end
+
+end

data/lib/ceedling/test_invoker/test_includes_extractinator.rb

@@ -0,0 +1,34 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Stage 4: a test file's #includes, from the real preprocessor. Stage 2's text scan
+# reads every #include as written; this stage replaces that list with what the
+# preprocessor found, in three passes that build on each other.
+#
+# 1. Bare includes (TestBareIncludesExtractinator): GCC's list from an isolated copy of
+#    the test file, with the test file's literal #includes added as candidates and
+#    stand-ins placed for their mocks and Partials.
+# 2. Preprocessed includes (TestIncludesPreprocessinator): the preprocessor runs over the
+#    test file, following its #includes through the stand-ins. Without -fdirectives-only,
+#    a plain expansion stands in, as a best effort.
+# 3. Reconciliation (TestIncludesReconcilinator): the second pass's #includes, checked
+#    against the candidates, replace the stored text-scan list.
+class TestIncludesExtractinator
+
+  constructor(
+    :test_bare_includes_extractinator,
+    :test_includes_preprocessinator,
+    :test_includes_reconcilinator
+  )
+
+  def stage_collect_preprocessor_context(state)
+    @test_bare_includes_extractinator.collect( state )
+    @test_includes_preprocessinator.preprocess( state )
+    @test_includes_reconcilinator.reconcile( state )
+  end
+
+end

data/lib/ceedling/test_invoker/test_includes_preprocessinator.rb

@@ -0,0 +1,118 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+require 'ceedling/test_invoker/test_pipeline_helpers'
+
+# Stage 4's second pass. The preprocessor runs over each test file with its full search
+# paths, following its #includes through the stand-ins into the headers they name. The
+# output's line markers record which #includes came from the test file itself.
+#
+# With -fdirectives-only, the output also keeps macros, and a compacted copy serves stage
+# 11. Without it, in fallback, a plain expansion stands in. Its line markers carry the same
+# record, but fallback is best effort: a file that fails to expand in full is left to its
+# text-scan #includes, checked against GCC's bare list.
+#
+# The output depends on every file it read, a mocked header through its stand-in among
+# them, so those files are registered as its dependencies, as a compile registers its .d
+# file.
+class TestIncludesPreprocessinator
+
+  include TestPipelineHelpers
+
+  # What differs between the pass's two ways of running: where its output goes and what
+  # makes it, the testable key that records it, and any further output it vouches for
+  MODES = {
+    directives_only: {
+      noun: 'directives-only', key: :directives_only, tool: :tools_test_file_directives_only_preprocessor,
+      target: :form_preprocessed_file_raw_directives_only_filepath, generate: :generate_directives_only_output,
+      outputs: [:form_preprocessed_file_compacted_directives_only_filepath]
+    },
+    fallback: {
+      noun: 'fallback', key: :fallback_expansion, tool: :tools_test_file_full_preprocessor,
+      target: :form_preprocessed_file_fallback_expansion_filepath, generate: :generate_fallback_expansion_output,
+      outputs: []
+    }
+  }.freeze
+
+  constructor(
+    :configurator,
+    :loginator,
+    :reportinator,
+    :batchinator,
+    :preprocessinator,
+    :file_path_utils,
+    :file_wrapper,
+    :dependinator
+  )
+
+  def preprocess(state)
+    mode    = current_mode()
+    skipped = 0
+
+    @batchinator.exec( workload: :compile, things: state.testables ) do |_, testable|
+      target = register( testable, mode )
+      stale  = @dependinator.stale?( target )
+
+      testable.preprocess[mode[:key]][:filepath] = stale ? generate( testable, target, mode ) : recall( testable, target, mode )
+      state.lock.synchronize { skipped += 1 } unless stale
+    end
+
+    log_skip_summary( task: "#{mode[:noun]} preprocessing", count: skipped, noun: "test files" )
+  end
+
+  private
+
+  # Chosen per run, since the configurator settles directives-only support after this
+  # object is built
+  def current_mode
+    return MODES[@configurator.test_build_preprocess_directives_only_available ? :directives_only : :fallback]
+  end
+
+  # The output path is deterministic, so it can be registered and checked before deciding
+  # whether to run the preprocessor at all
+  def register(testable, mode)
+    target = @file_path_utils.public_send( mode[:target], testable.filepath, testable.name )
+    meta   = dependency_meta(
+      flags: testable.preprocess_flags, defines: testable.preprocess_defines, search_paths: testable.search_paths,
+      tools: [@configurator.public_send( mode[:tool] )]
+    )
+
+    @dependinator.register( target, files: [testable.filepath], meta: meta )
+    register_preprocessed_dependencies( target, target ) if @file_wrapper.exist?( target )
+
+    return target
+  end
+
+  def recall(testable, target, mode)
+    log_module_progress( "Skipping #{mode[:noun]} preprocessing for", testable, Verbosity::OBNOXIOUS )
+    return target
+  end
+
+  # Gives the output's path, or nil when the preprocessor failed. A failure writes nothing
+  # to mark fresh, so the next run tries again.
+  def generate(testable, target, mode)
+    log_module_progress( 'Preprocessing test files for follow-on details extraction steps', testable, Verbosity::OBNOXIOUS )
+
+    output = @preprocessinator.public_send(
+      mode[:generate], filepath: testable.filepath, test: testable.name, flags: testable.preprocess_flags,
+      include_paths: testable.search_paths, vendor_paths: vendor_search_paths(), defines: testable.preprocess_defines
+    )
+    mark_fresh( testable, target, mode ) unless output.nil?
+
+    return output
+  end
+
+  # Any further file the same run wrote is registered as an output, so the target vouches for it
+  def mark_fresh(testable, target, mode)
+    outputs = mode[:outputs].map { |builder| @file_path_utils.public_send( builder, testable.filepath, testable.name ) }
+    @dependinator.register( target, outputs: outputs ) unless outputs.empty?
+    register_preprocessed_dependencies( target, target )
+    @dependinator.mark_fresh( target )
+  end
+
+end

data/lib/ceedling/test_invoker/test_includes_reconcilinator.rb

@@ -0,0 +1,149 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+require 'ceedling/includes/includes'
+require 'ceedling/test_invoker/test_pipeline_helpers'
+
+# Stage 4's third pass. The second pass's #includes, checked against the first pass's
+# candidates and the #includes a macro names, replace each test file's stored text-scan
+# list, and its mock search paths narrow to the mocks that remain. An empty result never
+# replaces a text scan that found #includes, and with neither pass to go on, the text scan
+# stands as it is.
+#
+# In fallback the second pass's output is a plain expansion, so reconciling against it is
+# a best effort. No dependency-tracker gate: this pass parses the second pass's
+# already-gated output or does a cheap text scan, and reconciling is list merging.
+class TestIncludesReconcilinator
+
+  include TestPipelineHelpers
+
+  constructor(
+    :configurator,
+    :loginator,
+    :reportinator,
+    :batchinator,
+    :test_context_extractor,
+    :preprocessinator,
+    :test_search_paths,
+    :mock_locator
+  )
+
+  def setup()
+    @context_extractor = @test_context_extractor
+  end
+
+  def reconcile(state)
+    @batchinator.exec( workload: :compile, things: state.testables ) do |_, testable|
+      ingest( testable )
+      narrow_mock_search_paths( state, testable )
+    end
+  end
+
+  private
+
+  # Reconciling to nothing while the text names #includes means preprocessing found none it
+  # should have. Ingesting would replace the test's header and source #includes with that
+  # nothing, so stage 2's list stands instead.
+  def ingest(testable)
+    return keep_text_scan( testable ) if nothing_preprocessed?( testable )
+
+    includes = reconciled_includes( testable )
+    return warn_of_text_scan( testable ) if includes.empty? && text_scanned?( testable )
+
+    @loginator.log_list( includes, "Extracted reconciled #include list from #{testable.filepath}:", Verbosity::OBNOXIOUS )
+    @context_extractor.ingest_includes( testable.filepath, includes )
+  end
+
+  # A test file's own #include of a mock is deliberate, so mocked headers are kept
+  def reconciled_includes(testable)
+    user, system = accurate_includes( testable )
+    return @preprocessinator.reconcile_includes(
+      bare: bare( testable ), user: user, system: system, test_filepath: testable.filepath, drop_mocked: false
+    )
+  end
+
+  def text_scanned?(testable)
+    return [:lookup_all_header_includes_list, :lookup_source_includes_list].any? do |lookup|
+      !@context_extractor.public_send( lookup, testable.filepath ).empty?
+    end
+  end
+
+  def warn_of_text_scan(testable)
+    msg = "No #includes of #{testable.filepath} survived reconciliation, though its text names some. Using the text-scanned " \
+          "#includes as a best effort. Rerun with --verbosity=obnoxious to see why preprocessing found none."
+    @loginator.log( msg, Verbosity::COMPLAIN )
+  end
+
+  # GCC's list is empty and the second pass failed: GCC's run failed too, or every #include
+  # sits in a branch that is off. Either way nothing is left to check the text scan against.
+  def nothing_preprocessed?(testable)
+    return testable.preprocess[:includes].empty? && preprocessed_filepath( testable ).nil?
+  end
+
+  # Stage 2's text-scan list stands, the Partial headers its configuration added included.
+  # This is a best effort: mocks in branches that are off stay with it.
+  def keep_text_scan(testable)
+    log_module_progress( 'Using fallback text-only includes extracted for', testable, Verbosity::OBNOXIOUS, LogLabels::WARNING )
+  end
+
+  # The user and system #includes from the second pass's output, or from the text scan
+  # when that pass failed for this file
+  def accurate_includes(testable)
+    preprocessed = preprocessed_filepath( testable )
+
+    if preprocessed.nil?
+      log_module_progress( 'Using fallback text-only includes extracted for', testable, Verbosity::OBNOXIOUS, LogLabels::WARNING )
+      includes = @context_extractor.lookup_all_header_includes_list( testable.filepath )
+      return [Includes.user( includes ), Includes.system( includes )]
+    end
+
+    log_module_progress( 'Reconciling #includes from best-effort fallback preprocessing for', testable, Verbosity::OBNOXIOUS, LogLabels::WARNING ) unless directives_only?
+    args = { name: testable.name, filepath: testable.filepath, directives_only_filepath: preprocessed }
+    return [@preprocessinator.preprocess_user_includes( **args ), @preprocessinator.preprocess_system_includes( **args )]
+  end
+
+  # With the second pass's output, the candidates plus the #includes a macro names, which
+  # that output resolved. Without it, the text-scanned #includes stand in for the second
+  # pass, and checking them against candidates holding those same #includes would keep
+  # every one, mocks in branches that are off included. GCC's list alone still evaluated
+  # those branches.
+  def bare(testable)
+    preprocessed = preprocessed_filepath( testable )
+    return testable.preprocess[:includes] if preprocessed.nil?
+
+    return @preprocessinator.supplement_with_computed_includes(
+      filepath: testable.filepath, bare: testable.preprocess[:candidates], directives_only_filepath: preprocessed
+    )
+  end
+
+  # The second pass's line-marker output, whichever way it ran, or nil when it failed for
+  # this file
+  def preprocessed_filepath(testable)
+    return testable.preprocess[:directives_only][:filepath] || testable.preprocess.dig( :fallback_expansion, :filepath )
+  end
+
+  def directives_only?
+    return @configurator.test_build_preprocess_directives_only_available
+  end
+
+  # The candidates' mock directories served the second pass. Once reconciled, only the
+  # mocks that remain need a search path. A remaining mock whose header is missing or
+  # mis-cased is reported by stage 5, which resolves every mock strictly.
+  def narrow_mock_search_paths(state, testable)
+    return if testable.paths[:mocks].nil?
+
+    mock_dirs = @mock_locator.directories(
+      @context_extractor.lookup_mock_header_includes_list( testable.filepath ),
+      mocks_root: testable.paths[:mocks],
+      collection: @mock_locator.header_collection( testable.search_paths, testable.mock_search_paths ),
+      complain:   :silent
+    )
+    @test_search_paths.assign_mock_search_paths( testable, mock_dirs, state.lock )
+  end
+
+end

data/lib/ceedling/test_invoker/test_invoker.rb

@@ -18,14 +18,11 @@ class TestInvoker
 
   constructor(
     :application,
-    :configurator,
-    :test_build_setup,
-    :test_build_planner,
-    :test_build_executor,
     :plugin_manager,
-    :batchinator,
+    :dependinator,
     :loginator,
-    :verbosinator
+    :verbosinator,
+    :test_pipeline_manager
   )
 
   def setup
@@ -36,27 +33,20 @@ class TestInvoker
   # Public API
   # -------------------------------------------------------------------------
 
-  # Run the test-build pipeline for the given tests.
-  #
-  # options: — free-form hash forwarded to every pipeline stage as `state.options`.
-  # Recognized keys (stages not listed read nothing from `options`):
-  #   :build_only   — Boolean. Skip stage 17 (Executing) only. Compile and link
-  #                   test executables but do not run them.
-  #   :sources_only — Boolean. Skip stages 15-17 (Building Objects, Building Test
-  #                   Executables, Executing). Runs only context-extraction/metadata
-  #                   stages 1-14, enough to populate each testable's `.sources` —
-  #                   i.e. no compiler, linker, or test fixture is invoked.
-  #   :test_linker  — Tool config for stage 16 (Building Test Executables). Ignored
-  #                   when :sources_only or :build_only skips that stage.
-  #   :test_fixture — Tool config for stage 17 (Executing). Ignored when :sources_only
-  #                   or :build_only skips that stage.
-  # Other keys occasionally merged in by callers (e.g. :test_compiler, :force_run) are
-  # currently not read by any pipeline stage; tool selection for compiling is instead
-  # resolved per-context via the `pre_compile_execute` plugin hook.
-  def setup_and_invoke(tests:, context: TEST_SYM, options: {})
+  # Runs the test-build pipeline for the given tests. `options:` is a flat Array of
+  # Symbols controlling pipeline behavior -- see TestPipelineManager for the full set
+  # of recognized flags and their effect on the stage sequence.
+  def setup_and_invoke(tests:, context: TEST_SYM, options: [])
     timestamp_s = SystemWrapper.time_stopwatch_s()
     @plugin_manager.pre_test_build( context, timestamp_s )
 
+    # `identifier: context` isolates this run's own cache file (see Dependinator#open) --
+    # a plugin building its own variant of the test pipeline under a distinct context
+    # (:gcov, :valgrind, ...) gets its own cache automatically, never sharing one with
+    # ordinary :test runs (or another plugin's context) and never exposed to a full
+    # :test run's own pruning flush evicting its entries.
+    @dependinator.open( identifier: context )
+
     @state = PipelineState.new(
       tests:            tests,
       testables:        {},
@@ -70,12 +60,13 @@ class TestInvoker
     )
 
     begin
-      run_pipeline( build_stage_sequence(), @state )
+      @test_pipeline_manager.run( @state )
     rescue StandardError => ex
       @application.register_build_failure
       @loginator.log( ex.message, Verbosity::ERRORS, LogLabels::EXCEPTION )
       @loginator.log_debug_backtrace( ex )
     ensure
+      @dependinator.flush( refresh_dependencies: options.include?(:refresh_dependencies) )
       @plugin_manager.post_test_build( context, SystemWrapper.time_stopwatch_s() )
     end
   end
@@ -90,162 +81,4 @@ class TestInvoker
     return @state.testables[test.to_sym].sources
   end
 
-  # -------------------------------------------------------------------------
-  # Pipeline infrastructure
-  # -------------------------------------------------------------------------
-
-  private
-
-  def run_pipeline(stages, state)
-    stages.each do |stage|
-      next unless stage.run?( state )
-
-      if stage.transform
-        stage.body.call( state )
-      else
-        @batchinator.build_step( stage.name, heading: stage.heading ) do
-          stage.body.call( state )
-        end
-      end
-    end
-  end
-
-  def build_stage_sequence
-    use_preprocessing = -> (s) { @configurator.project_use_test_preprocessor_tests }
-    use_partials      = -> (s) { @configurator.project_use_partials }
-    use_mocks         = -> (s) { @configurator.project_use_mocks }
-    use_mocks_preproc = -> (s) { @configurator.project_use_mocks && @configurator.project_use_test_preprocessor_mocks }
-    not_build_only    = -> (s) { !s.options[:build_only] }   # skip stage 17 only
-    not_sources_only  = -> (s) { !s.options[:sources_only] } # skip stages 15-17
-
-    [
-      # Stage 1
-      stage("Preparing Build Paths",
-            heading: false,
-            body: ->(s) { @test_build_setup.stage_prepare_build_paths(s) }
-      ),
-
-      # Stage 2
-      stage("Collecting Essential Test Context",
-            body: ->(s) { @test_build_setup.stage_collect_test_context(s) }
-      ),
-
-      # Stage 3
-      stage("Ingesting Test Configurations",
-            body: ->(s) { @test_build_setup.stage_ingest_configurations(s) }
-      ),
-
-      # Stage 4
-      stage("Collecting More Test Context",
-            condition: use_preprocessing,
-            body: ->(s) { @test_build_setup.stage_collect_preprocessor_context(s) }
-      ),
-
-      # Stage 5
-      stage("Determining Files to Be Generated",
-            heading: false,
-            body: ->(s) { @test_build_planner.stage_determine_files(s) }
-      ),
-
-      # Transform 1: Prepare partials parallel processing
-      stage(transform: true,
-            condition: use_partials,
-            body: ->(s) { @test_build_planner.stage_flatten_partials_lists(s) }
-      ),
-
-      # Stage 6
-      stage("Preprocessing for Testing & Mocking Partials",
-            condition: use_partials,
-            body: ->(s) { @test_build_executor.stage_preprocess_partial_headers(s) }
-      ),
-
-      # Stage 7
-      stage("Preprocessing for Testing Partials",
-            condition: use_partials,
-            body: ->(s) { @test_build_executor.stage_preprocess_partial_sources(s) }
-      ),
-
-      # Stage 8
-      stage("Partials",
-            condition: use_partials,
-            body: ->(s) { @test_build_executor.stage_generate_partials(s) }
-      ),
-
-      # Transform 2: Prepare mocks for parallel processing
-      stage(transform: true,
-            condition: use_mocks,
-            body: ->(s) { @test_build_planner.stage_flatten_mocks_list(s) }
-      ),
-
-      # Stage 9
-      stage("Preprocessing for Mocks",
-            condition: use_mocks_preproc,
-            body: ->(s) { @test_build_executor.stage_preprocess_mocks(s) }
-      ),
-
-      # Stage 10
-      stage("Mocking",
-            condition: use_mocks,
-            body: ->(s) { @test_build_executor.stage_generate_mocks(s) }
-      ),
-
-      # Stage 11
-      stage("Preprocessing Test Files",
-            condition: use_preprocessing,
-            body: ->(s) { @test_build_executor.stage_preprocess_test_files(s) }
-      ),
-
-      # Stage 12
-      stage("Collecting More Test Context",
-            condition: use_preprocessing,
-            body: ->(s) { @test_build_executor.stage_collect_runner_details(s) }
-      ),
-
-      # Stage 13
-      stage("Test Runners",
-            body: ->(s) { @test_build_executor.stage_generate_runners(s) }
-      ),
-
-      # Stage 14
-      stage("Determining Artifacts to Be Built",
-            heading: false,
-            body: ->(s) { @test_build_planner.stage_determine_artifacts(s) }
-      ),
-
-      # Transform 3: Prepare objects for parallel processing
-      stage(transform: true,
-            body: ->(s) { @test_build_planner.stage_flatten_objects_list(s) }
-      ),
-
-      # Stage 15 — skipped under :sources_only (no object compilation needed to
-      # determine which sources a test references).
-      stage("Building Objects",
-            condition: not_sources_only,
-            body: ->(s) { @test_build_executor.stage_build_objects(s) }
-      ),
-
-      # Stage 16 — skipped under :sources_only (no linking needed either).
-      stage("Building Test Executables",
-            condition: not_sources_only,
-            body: ->(s) { @test_build_executor.stage_build_executables(s) }
-      ),
-
-      # Stage 17 — skipped under :build_only or :sources_only.
-      stage("Executing",
-            condition: ->(s) { not_build_only.call(s) && not_sources_only.call(s) },
-            body: ->(s) { @test_build_executor.stage_execute(s) }
-      ),
-    ]
-  end
-
-  def stage(name = nil, heading: true, condition: nil, transform: false, body:)
-    Stage.new(
-      name:      name,
-      heading:   heading,
-      condition: condition,
-      transform: transform,
-      body:      body
-    )
-  end
-
 end