ceedling 1.1.10 → 1.2.0

data/lib/ceedling/test_invoker/test_invoker_types.rb

@@ -8,21 +8,60 @@
 module TestInvokerTypes
 
   # Partial build metadata for one test: config map plus accumulated output module names.
-  TestablePartials = Struct.new(:configs, :tests, :mocks, keyword_init: true)
+  TestablePartials = Struct.new(:configs, :tests, :mocks, keyword_init: true) unless const_defined?(:TestablePartials, false)
 
   # Carries all mutable state across the pipeline stages.
   PipelineState = Struct.new(
     :tests,             # Array of test filepaths (input to stage 1)
     :testables,         # Hash<Symbol, Testable> — accumulated across all stages
     :context,
-    :options,
-    :partials_headers,  # Produced by T1; consumed by stages 6 & 7
-    :partials_sources,  # Produced by T1; consumed by stages 6 & 7
-    :mocks_list,        # Produced by T2; consumed by stages 9 & 10
-    :objects_list,      # Produced by T3; consumed by stage 15
+    :options,           # Array<Symbol> — pipeline-control flags (see TestPipelineManager)
+    :partials_headers,  # Array<PartialWork> — produced by T1; consumed by stages 6 & 7
+    :partials_sources,  # Array<PartialWork> — produced by T1; consumed by stages 6 & 7
+    :mocks_list,        # Array<MockWork> — produced by T2; consumed by stages 9 & 10
+    :objects_list,      # Array<ObjectWork> — produced by T3; consumed by stage 15
     :lock,              # Mutex for thread-safe testable writes
     keyword_init: true
-  )
+  ) do
+    def initialize(**kwargs)
+      kwargs[:options] ||= []
+      super(**kwargs)
+    end
+  end unless const_defined?(:PipelineState, false)
+
+  # A resolved mock: its own header's real, resolved location (`source`, also
+  # duplicated onto `filepath`), the mirrored subdirectory it lives in below
+  # this test's mock root (`path`), whichever of the two the compiler should
+  # actually read (`input` -- the raw header or its preprocessed output,
+  # depending on whether mock preprocessing is enabled), and whether this
+  # mock is Ceedling's own generated Partial content rather than a mock of a
+  # real header (`partial`). `include_path` is the #include as the test wrote
+  # it. It names the mock for CMock and the runner alike.
+  MockDetails = Struct.new(:name, :filepath, :path, :source, :input, :partial, :include_path, keyword_init: true) unless const_defined?(:MockDetails, false)
+
+  # A test's generated Unity runner: the C file to be compiled (`output_filepath`)
+  # and the (possibly preprocessed) test file it was generated from (`input_filepath`).
+  RunnerInfo = Struct.new(:output_filepath, :input_filepath, keyword_init: true) unless const_defined?(:RunnerInfo, false)
+
+  # One partial header or source file's own preprocessing work, flattened out of its
+  # owning testable for parallel processing (T1). `preprocessed_target` and `stale` are
+  # unset until the corresponding stage settles this target's staleness.
+  PartialWork = Struct.new(
+    :config, :testable, :directives_only_filepath, :preprocessed_target, :stale,
+    keyword_init: true
+  ) unless const_defined?(:PartialWork, false)
+
+  # One mock's own preprocessing/generation work, flattened out of its owning testable
+  # for parallel processing (T2). `details` is this mock's own MockDetails; `preprocessed_target`
+  # and `stale` are unset until the corresponding stage settles this target's staleness.
+  MockWork = Struct.new(
+    :name, :details, :testable, :directives_only_filepath, :preprocessed_target, :stale,
+    keyword_init: true
+  ) unless const_defined?(:MockWork, false)
+
+  # One object file's own compile work, flattened out of its owning testable's object
+  # list for parallel processing (T3) -- `test` names which testable it came back to.
+  ObjectWork = Struct.new(:test, :obj, keyword_init: true) unless const_defined?(:ObjectWork, false)
 
   # Named record replacing the raw hash per test file. Fields are populated
   # across multiple stages; nil fields are valid until their stage sets them.
@@ -30,27 +69,57 @@ module TestInvokerTypes
     :filepath, :name,
     :paths,                                    # Hash — build/results/mocks/partials/preprocess paths
     :preprocess,                               # Hash — preprocessing scratch state
+    :mock_search_paths,                        # Array — each mocked header's own mirrored
+                                                # directory below this test's mock root, folded
+                                                # into search_paths so a mock is still findable
+                                                # by however little path its own #include wrote
     :search_paths,
     :compile_flags, :preprocess_flags, :assembler_flags, :link_flags,
     :compile_defines, :preprocess_defines,
-    :runner,                                   # Hash — {output_filepath:, input_filepath:}
-    :mocks,                                    # Hash — mock name → mock info
+    :runner,                                   # RunnerInfo
+    :mocks,                                    # Hash — mock name (Symbol) → MockDetails
     :partials,                                 # TestablePartials — configs map + tests/mocks module name lists
-    :sources, :frameworks, :core, :objects, :executable,
-    :no_link_objects, :results_pass, :results_fail,
+    :sources, :frameworks, :core, :objects, :executable, :results_pass,
+    :executable_rebuilt,                       # Boolean — set by stage 16, read by stage 17 to decide
+                                                # whether to run the fixture. Carried on the struct rather
+                                                # than re-querying the dependency tracker in stage 17: by
+                                                # then the executable has already been marked fresh (if it
+                                                # was rebuilt), so a fresh staleness query would always
+                                                # answer false regardless of what actually happened.
+    :isolated_headers_path,                    # String — set by stage 15's own sibling-header isolation
+                                                # (TestBuildExecutor#isolate_sibling_headers) the first time
+                                                # this test's own file compile finds a real header sharing a
+                                                # directory with a mocked/Partialized header. Scoped to this
+                                                # one test's whole build rather than any single object, so
+                                                # every object compiled afterward sees the same corrected
+                                                # search paths; nil until (if ever) that happens, and read
+                                                # once more at the very end of stage 15 to know what to clean up.
     keyword_init: true
   ) do
     def initialize(**kwargs)
-      kwargs[:partials] ||= TestablePartials.new(configs: {}, tests: [], mocks: [])
+      kwargs[:partials]           ||= TestablePartials.new(configs: {}, tests: [], mocks: [])
+      kwargs[:mock_search_paths]  ||= []
       super(**kwargs)
     end
-  end
+  end unless const_defined?(:Testable, false)
 
   # Describes one pipeline step — either a named build_step or a silent transform.
-  Stage = Struct.new(:name, :heading, :condition, :transform, :body, keyword_init: true) do
-    def run?(state)
+  # `condition` gates whether this stage's feature is in play at all for the project
+  # (e.g. Partials or mocking enabled) -- when false, the stage is skipped in total
+  # silence, exactly as if it didn't exist. `empty_condition` (nil for most stages)
+  # gates a narrower case: the feature IS enabled, but this particular run happens to
+  # have none of that stage's kind of work to do -- when true, the stage's heading and
+  # body are both skipped, but `empty_notice` is logged at OBNOXIOUS so a verbose run
+  # can still see that the stage was considered and correctly found nothing to do,
+  # distinct from the feature being off project-wide.
+  Stage = Struct.new(:name, :heading, :condition, :empty_condition, :empty_notice, :transform, :body, keyword_init: true) do
+    def enabled?(state)
       condition.nil? || condition.call(state)
     end
-  end
+
+    def empty?(state)
+      !empty_condition.nil? && empty_condition.call(state)
+    end
+  end unless const_defined?(:Stage, false)
 
 end

data/lib/ceedling/test_invoker/test_pipeline_helpers.rb

@@ -0,0 +1,121 @@
+# =========================================================================
+#   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/path_mirror'
+
+# Small helpers shared by more than one test pipeline stage class. Relies on
+# `@reportinator`/`@loginator` already being present via whichever including
+# class's own constructor DI provides them, the same way TestInvokerTypes is
+# mixed in without any DI wiring of its own.
+module TestPipelineHelpers
+
+  # States, in one line, how many targets a build step left untouched because nothing
+  # about their antecedents changed -- silence would otherwise read as the step doing
+  # nothing at all, indistinguishable from a misconfigured or broken stage.
+  def log_skip_summary(task:, count:, noun:, reason: "nothing changed")
+    msg = @reportinator.generate_skip_summary( task: task, count: count, noun: noun, reason: reason )
+    @loginator.log( msg ) unless msg.nil?
+  end
+
+  # Logs a step of a test's build, naming the test and its file
+  def log_module_progress(operation, testable, verbosity = Verbosity::NORMAL, label = LogLabels::AUTO)
+    msg = @reportinator.generate_module_progress(
+      operation:   operation,
+      module_name: testable.name,
+      filename:    File.basename( testable.filepath )
+    )
+    @loginator.log( msg, verbosity, label )
+  end
+
+  # Ceedling's own vendor headers/sources (Unity, CMock, CException, the generated
+  # ceedling.h) live outside every configured :test/:source/:support/:include root, so
+  # any preprocessor invocation resolving a test's own #includes needs this path handed
+  # to it directly alongside those configured roots, or it would never find them.
+  def vendor_search_paths()
+    [@configurator.project_build_vendor_ceedling_path]
+  end
+
+  # A dependency-tracker target's staleness is only as accurate as the meta it's
+  # registered with -- flags, defines, and search paths all affect a preprocess or
+  # compile target's actual output, so all three ride along as meta everywhere a
+  # target derived from any of them is registered.
+  #
+  # `tools:` carries the config for whichever :tools entry (or entries) actually
+  # ran to produce this target -- a repointed :executable, an added argument, a
+  # changed :name or :optional/:stderr_redirect setting should all invalidate the
+  # target the same as a changed flag would, even though none of those live in
+  # `flags`. Defaults to an empty list for a caller with no shell tool of its own.
+  #
+  # `preprocess_force_fallback:` defaults to this run's actual
+  # :test_build ↳ :preprocess_force_fallback setting, so every ordinary caller
+  # picks it up without having to ask for it explicitly -- toggling that setting
+  # between runs, with nothing else changed, should still invalidate whatever a
+  # preprocessing pass produced.
+  #
+  # `partials:` is left out of the returned hash entirely when not given, so a
+  # caller with nothing to do with Partials never carries a meaningless `nil`.
+  def dependency_meta(flags:, defines:, search_paths:, tools: [], preprocess_force_fallback: @configurator.test_build_preprocess_force_fallback, partials: nil)
+    meta = { flags: flags, defines: defines, search_paths: search_paths, tools: tools, preprocess_force_fallback: preprocess_force_fallback }
+    meta[:partials] = partials unless partials.nil?
+    meta
+  end
+
+  # Registers the project files a preprocessor's output entered as `target`'s
+  # dependencies, as a compile registers its .d file. Files below the build root, such as
+  # stand-ins and generated mocks, derive from those project files and would only ever
+  # look changed. Relies on `@preprocessinator` and `@dependinator`.
+  def register_preprocessed_dependencies(target, output)
+    build_root = File.join( @configurator.project_build_root, '' )
+    files      = @preprocessinator.preprocessed_dependencies( preprocessed_filepath: output )
+
+    @dependinator.register( target, files: files.reject { |file| file.start_with?( build_root ) } )
+  end
+
+  # A preprocessing pass falls back to plain, non-directives-only handling either when
+  # directives-only support isn't available at all for this toolchain, or when this
+  # particular target's own directives-only output failed to generate (see
+  # generate_directives_only_output) despite support existing project-wide.
+  def directives_only_fallback?(directives_only, directives_only_filepath)
+    !directives_only or directives_only_filepath.nil?
+  end
+
+  # A Partial mock is Ceedling's own generated content, identifiable by its own naming
+  # convention rather than by any real header it corresponds to (it has none).
+  def mock_partial?(include)
+    include.filename.start_with?( @configurator.cmock_mock_prefix + PARTIAL_FILENAME_PREFIX )
+  end
+
+  # A Partial's own module name doubles as its generated source file's basename, so an
+  # object list built from #include-derived sources can end up carrying an object for a
+  # module that a Partial has already taken over -- this removes those, leaving the
+  # Partial's own separately-generated source as the module's only linked object.
+  #
+  # The original module's own source is still compiled like every other source in the
+  # test's compile list (stage 15) -- only its membership among the objects handed to the
+  # linker (TestBuildExecutor#stage_build_executables, stage 16) is trimmed, right before
+  # linking. Compiling it unconditionally keeps that source's own dependency tracking (and,
+  # under coverage profiling -- gcov, Bullseye -- its #line-directive mapping of a Partial's
+  # generated code back to the original module's own lines) working the same way it does for
+  # every other source, rather than carving out a special case for whether the result of
+  # compiling it is ever actually linked.
+  # A Partialized module's own object must not reach the link, since the generated
+  # Partial already carries that module's functions.
+  #
+  # An object's path mirrors its source's own directory below the configured roots, so
+  # a module is matched by the end of that path. Matching on basename alone would also
+  # take a same-named module's object from another directory, dropping a module the
+  # test never Partialized and losing its functions from the link.
+  def remove_partials_source_objects(objects, configs)
+    queries = configs.keys.map { |_module| PathMirror.path_segments( _module ) }
+
+    objects.delete_if do |filepath|
+      segments = PathMirror.path_segments( filepath.ext( '' ) )
+      queries.any? { |query| segments.last( query.length ) == query }
+    end
+  end
+
+end

data/lib/ceedling/test_invoker/test_pipeline_manager.rb

@@ -0,0 +1,303 @@
+# =========================================================================
+#   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/exceptions'
+require 'ceedling/test_invoker/test_invoker_types'
+
+# Owns the test-build pipeline's shape: what stages exist, in what order, and
+# which of `state.options` gates each one. `TestInvoker` owns everything
+# around a run (state setup, dependency-cache lifecycle, plugin hooks,
+# top-level error handling); this class owns the run itself.
+class TestPipelineManager
+
+  include TestInvokerTypes
+
+  constructor(
+    :test_build_setup,
+    :test_includes_extractinator,
+    :test_build_planner,
+    :partials_manager,
+    :test_build_executor,
+    :test_file_preprocessinator,
+    :test_runner_generatinator,
+    :configurator,
+    :batchinator,
+    :loginator,
+    :reportinator
+  )
+
+  # `options:` (an Array of Symbols; see `TestInvoker#setup_and_invoke`) is a flat
+  # collection of independent pipeline-control flags. Recognized symbols:
+  #
+  #   :mocking              — Stop the pipeline after stage 10 (Mocking). Skips
+  #                           stages 11-17 (test-file preprocessing, runner details/
+  #                           generation, artifact determination, object compilation,
+  #                           linking, execution).
+  #   :test_runner          — Stop the pipeline after stage 13 (Test Runners). Skips
+  #                           stages 14-17 (artifact determination, object compilation,
+  #                           linking, execution).
+  #   :build_only           — Skip stage 17 (Executing) only. Compile and link test
+  #                           executables but do not run them.
+  #   :sources_only         — 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.
+  #   :refresh_dependencies — Read by `TestInvoker`, not by any stage here. Included
+  #                           for completeness: permits the dependency cache to prune
+  #                           entries for targets this run didn't touch.
+  #
+  # `:mocking`, `:test_runner`, `:sources_only`, and `:build_only` each name a single,
+  # different point at which the pipeline stops -- supplying more than one at once is
+  # ambiguous and rejected by `validate_stop_point_options!` below.
+  STOP_POINT_OPTIONS = %i[mocking test_runner sources_only build_only].freeze unless const_defined?(:STOP_POINT_OPTIONS, false)
+
+  # Read alongside STOP_POINT_OPTIONS above -- named per stop point so a mocks-only or
+  # runners-only run's quieter console output (fewer stage headings, no pass/fail
+  # summary) is never mistaken for a truncated or broken full test build.
+  STOP_POINT_ANNOUNCEMENTS = {
+    mocking:      "Generating mocks only -- no test runners, compiling, linking, or running.",
+    test_runner:  "Generating mocks and test runners only -- no compiling, linking, or running.",
+    build_only:   "Building test executables only -- not running them.",
+    sources_only: "Determining test sources only -- no generating, compiling, linking, or running.",
+  }.freeze unless const_defined?(:STOP_POINT_ANNOUNCEMENTS, false)
+
+  # Read alongside STOP_POINT_ANNOUNCEMENTS above -- header text for each stop point's
+  # own final completion banner (see announce_completion), so a mocks-only or
+  # runners-only run ends with a clear, deliberate signal of its own, the same way a
+  # full test run ends with its own "OVERALL TEST SUMMARY" banner.
+  STOP_POINT_BANNERS = {
+    mocking:      'MOCKS GENERATED',
+    test_runner:  'MOCKS & TEST RUNNERS GENERATED',
+    build_only:   'TEST EXECUTABLES BUILT',
+    sources_only: 'TEST SOURCES DETERMINED',
+  }.freeze unless const_defined?(:STOP_POINT_BANNERS, false)
+
+  # Validates `state.options`, then builds and runs the stage sequence against `state`.
+  def run(state)
+    validate_stop_point_options!( state.options )
+    announce_run_scope( state.options )
+
+    build_stage_sequence().each do |stage|
+      next unless stage.enabled?( state )
+
+      if stage.empty?( state )
+        @loginator.log( "#{stage.name}: #{stage.empty_notice}", Verbosity::OBNOXIOUS )
+        next
+      end
+
+      if stage.transform
+        stage.body.call( state )
+      else
+        @batchinator.build_step( stage.name, heading: stage.heading ) do
+          stage.body.call( state )
+        end
+      end
+    end
+
+    announce_completion( state.options )
+  end
+
+  private
+
+  def validate_stop_point_options!(options)
+    conflicts = STOP_POINT_OPTIONS.select { |key| options.include?( key ) }
+    return if conflicts.size <= 1
+
+    named = conflicts.map { |key| ":#{key}" }.join(', ')
+    raise CeedlingException.new(
+      "Pipeline options #{named} each stop the test-build pipeline at a different " \
+      "point -- specify at most one of #{STOP_POINT_OPTIONS.map { |k| ":#{k}" }.join(', ')}."
+    )
+  end
+
+  # Silent for an ordinary full test build (no stop-point option present) -- only a
+  # partial run announces itself, so the announcement's mere presence is itself the
+  # signal something less than a full build is happening.
+  def announce_run_scope(options)
+    stop_point = STOP_POINT_OPTIONS.find { |key| options.include?( key ) }
+    return if stop_point.nil?
+
+    @loginator.log( STOP_POINT_ANNOUNCEMENTS[stop_point], Verbosity::NORMAL, LogLabels::NOTICE )
+  end
+
+  # A specific final step, mirroring how a full test run's own "OVERALL TEST SUMMARY"
+  # banner is generated (ReportTestsStdoutPlugin, via this identical
+  # Reportinator#generate_banner) -- silent for a full test build, whose own
+  # results banner covers that case through its own, separate mechanism.
+  def announce_completion(options)
+    stop_point = STOP_POINT_OPTIONS.find { |key| options.include?( key ) }
+    return if stop_point.nil?
+
+    header = @loginator.decorate( STOP_POINT_BANNERS[stop_point], LogLabels::BUILT )
+    banner = @reportinator.generate_banner( header )
+    @loginator.log( "\n" + banner, Verbosity::NORMAL, LogLabels::NONE )
+  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_mocking       = -> (s) { !s.options.include?(:mocking) }       # skip stages 11-17 (stop after stage 10)
+    not_test_runner   = -> (s) { !s.options.include?(:test_runner) }   # skip stages 14-17 (stop after stage 13)
+    not_build_only    = -> (s) { !s.options.include?(:build_only) }    # skip stage 17 only
+    not_sources_only  = -> (s) { !s.options.include?(: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_includes_extractinator.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,
+            empty_condition: ->(s) { s.partials_headers.empty? },
+            empty_notice:    "no Partials to process",
+            body: ->(s) { @partials_manager.stage_preprocess_partial_headers(s) }
+      ),
+
+      # Stage 7
+      stage("Preprocessing for Testing Partials",
+            condition:       use_partials,
+            empty_condition: ->(s) { s.partials_sources.empty? },
+            empty_notice:    "no Partials to process",
+            body: ->(s) { @partials_manager.stage_preprocess_partial_sources(s) }
+      ),
+
+      # Stage 8
+      stage("Partials",
+            condition:       use_partials,
+            empty_condition: ->(s) { s.partials_headers.empty? && s.partials_sources.empty? },
+            empty_notice:    "no Partials to generate",
+            body: ->(s) { @partials_manager.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,
+            empty_condition: ->(s) { s.mocks_list.empty? },
+            empty_notice:    "no mocks to process",
+            body: ->(s) { @test_build_executor.stage_preprocess_mocks(s) }
+      ),
+
+      # Stage 10 — the :mocking stop point runs through here, then halts.
+      stage("Mocking",
+            condition:       use_mocks,
+            empty_condition: ->(s) { s.mocks_list.empty? },
+            empty_notice:    "no mocks to generate",
+            body: ->(s) { @test_build_executor.stage_generate_mocks(s) }
+      ),
+
+      # Stage 11 — skipped under :mocking.
+      stage("Preprocessing Test Files",
+            condition: ->(s) { use_preprocessing.call(s) && not_mocking.call(s) },
+            body: ->(s) { @test_file_preprocessinator.preprocess(s) }
+      ),
+
+      # Stage 12 — skipped under :mocking.
+      stage("Collecting Test Runner Details",
+            condition: ->(s) { use_preprocessing.call(s) && not_mocking.call(s) },
+            body: ->(s) { @test_runner_generatinator.collect_details(s) }
+      ),
+
+      # Stage 13 — skipped under :mocking. The :test_runner stop point runs
+      # through here, then halts.
+      stage("Test Runners",
+            condition: not_mocking,
+            body: ->(s) { @test_runner_generatinator.generate(s) }
+      ),
+
+      # Stage 14 — skipped under :mocking or :test_runner.
+      stage("Determining Artifacts to Be Built",
+            heading: false,
+            condition: ->(s) { not_mocking.call(s) && not_test_runner.call(s) },
+            body: ->(s) { @test_build_planner.stage_determine_artifacts(s) }
+      ),
+
+      # Transform 3: Prepare objects for parallel processing — skipped under
+      # :mocking or :test_runner.
+      stage(transform: true,
+            condition: ->(s) { not_mocking.call(s) && not_test_runner.call(s) },
+            body: ->(s) { @test_build_planner.stage_flatten_objects_list(s) }
+      ),
+
+      # Stage 15 — skipped under :mocking, :test_runner, or :sources_only
+      # (no object compilation needed to determine which sources a test references).
+      stage("Building Objects",
+            condition: ->(s) { not_mocking.call(s) && not_test_runner.call(s) && not_sources_only.call(s) },
+            body: ->(s) { @test_build_executor.stage_build_objects(s) }
+      ),
+
+      # Stage 16 — skipped under :mocking, :test_runner, or :sources_only
+      # (no linking needed either).
+      stage("Building Test Executables",
+            condition: ->(s) { not_mocking.call(s) && not_test_runner.call(s) && not_sources_only.call(s) },
+            body: ->(s) { @test_build_executor.stage_build_executables(s) }
+      ),
+
+      # Stage 17 — skipped under :mocking, :test_runner, :build_only, or :sources_only.
+      stage("Executing",
+            condition: ->(s) {
+              not_mocking.call(s) && not_test_runner.call(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, empty_condition: nil, empty_notice: nil, transform: false, body:)
+    Stage.new(
+      name:            name,
+      heading:         heading,
+      condition:       condition,
+      empty_condition: empty_condition,
+      empty_notice:    empty_notice,
+      transform:       transform,
+      body:            body
+    )
+  end
+
+end

data/lib/ceedling/test_invoker/test_runner_generatinator.rb

@@ -0,0 +1,105 @@
+# =========================================================================
+#   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'
+
+# Stages 12 and 13: each test's Unity runner. Stage 12 parses test case names from the
+# preprocessed test file, and stage 13 generates the runner from them and the test's
+# mock and include lists.
+#
+# Both stages check the one runner target, registered the same way. Test case names
+# exist only to feed the runner, so stage 12 does nothing when the runner is current.
+# Registration accumulates, and only stage 13 marks the target fresh.
+#
+# The runner depends on what it is generated from: the test file, the input file its
+# test case names are parsed from (the preprocessed test file, with test preprocessing),
+# and the test's mock and include lists. Those lists come from stage 4's reconciliation
+# with test preprocessing, so they can change while the test file doesn't, as when a
+# header's macro decides which mocks a test has.
+class TestRunnerGeneratinator
+
+  include TestPipelineHelpers
+
+  constructor(
+    :configurator,
+    :loginator,
+    :reportinator,
+    :batchinator,
+    :generator,
+    :test_context_extractor,
+    :dependinator
+  )
+
+  def setup()
+    @context_extractor = @test_context_extractor
+  end
+
+  # Stage 12
+  def collect_details(state)
+    each_stale( state, task: "test case name parsing", noun: "test files", skip: 'Skipping test case name parsing for' ) do |testable|
+      log_module_progress( 'Parsing test case names', testable )
+      @context_extractor.collect_test_runner_details( testable.filepath, testable.runner.input_filepath )
+    end
+  end
+
+  # Stage 13
+  def generate(state)
+    each_stale( state, task: "test runner generation", noun: "test runners", skip: 'Skipping test runner generation for' ) do |testable|
+      generate_runner( state, testable )
+    end
+  end
+
+  private
+
+  # Yields each test whose runner is stale, logging each one skipped and a summary
+  def each_stale(state, task:, noun:, skip:)
+    skipped = 0
+
+    @batchinator.exec( workload: :compile, things: state.testables ) do |_, testable|
+      next yield( testable ) if stale?( testable )
+
+      log_module_progress( skip, testable, Verbosity::OBNOXIOUS )
+      state.lock.synchronize { skipped += 1 }
+    end
+
+    log_skip_summary( task: task, count: skipped, noun: noun )
+  end
+
+  def stale?(testable)
+    files = [testable.filepath, testable.runner.input_filepath].uniq
+    @dependinator.register( testable.runner.output_filepath, files: files, meta: runner_meta( testable ) )
+    return @dependinator.stale?( testable.runner.output_filepath )
+  end
+
+  def generate_runner(state, testable)
+    @generator.generate_test_runner(
+      context:         state.context,
+      mocks:           @context_extractor.lookup_mock_header_includes_list( testable.filepath ),
+      includes:        @context_extractor.lookup_nonmock_header_includes_list( testable.filepath ),
+      test_filepath:   testable.filepath,
+      input_filepath:  testable.runner.input_filepath,
+      runner_filepath: testable.runner.output_filepath
+    )
+    @dependinator.mark_fresh( testable.runner.output_filepath )
+  end
+
+  # The real runner and Unity configuration, not project_config_hash's flattened
+  # sections, which never hold :test_runner or :unity. Whether test files are
+  # preprocessed decides where test case names come from, so toggling it alone must
+  # invalidate the runner. The mock and include lists are the runner's #includes.
+  def runner_meta(testable)
+    return {
+      test_runner:             @configurator.get_runner_config,
+      unity:                   @configurator.get_unity_config,
+      test_preprocessor_tests: @configurator.project_use_test_preprocessor_tests,
+      mocks:                   @context_extractor.lookup_mock_header_includes_list( testable.filepath ).map( &:filepath ),
+      includes:                @context_extractor.lookup_nonmock_header_includes_list( testable.filepath ).map( &:filepath )
+    }
+  end
+
+end