ceedling 1.2.0 → 1.2.2

data/lib/ceedling/test_invoker/partials_manager.rb

@@ -269,6 +269,8 @@ class PartialsManager
       end
     end
 
+    order_partials( partials.map { |partial| partial[:testable] }.uniq )
+
     log_skip_summary( task: "Partial types generation", count: skipped_types, noun: "types headers" )
     log_skip_summary( task: "Partial implementation generation", count: skipped_impl, noun: "implementations" )
     log_skip_summary( task: "Partial interface generation", count: skipped_interface, noun: "interfaces" )
@@ -296,6 +298,16 @@ class PartialsManager
   # and `config.includes` is recalled from the on-disk list a prior stale run wrote
   # -- so `config` ends up populated identically either way, and stage 8 (which
   # reads only `config`) needs no knowledge of which path produced it.
+  # Build threads finish in any order. Each test's Partial modules return to its configuration
+  # order, which its link and mock lists follow, so an unchanged build sees unchanged lists.
+  def order_partials(testables)
+    testables.each do |testable|
+      order = testable.partials.configs.values.map( &:module )
+      testable.partials.tests.sort_by! { |_module| order.index( _module ) }
+      testable.partials.mocks.sort_by! { |_module| order.index( _module ) }
+    end
+  end
+
   def preprocess_partials(items:, kind:, noun:, preserve_macros_method:, expand_macros_method:)
     directives_only = @configurator.test_build_preprocess_directives_only_available
     skipped = 0

data/lib/ceedling/test_invoker/standin_headerinator.rb

@@ -8,6 +8,7 @@
 require 'ceedling/constants'
 require 'ceedling/includes/includes'
 require 'ceedling/test_invoker/test_pipeline_helpers'
+require 'ceedling/filesystem/project_paths'
 
 # Stand-in headers: files placed where a test's mocks and Partials will be generated, so
 # the preprocessor finds something at each of their #includes before stage 8 or stage 10
@@ -46,7 +47,7 @@ class StandinHeaderinator
     mock_dirs = place_mocks( testable, mocks, complain )
     place_partials( testable, Includes.filter( includes, /^#{PARTIAL_FILENAME_PREFIX}/ ) )
 
-    return mock_dirs.uniq
+    return mock_dirs.flatten.uniq
   end
 
   private
@@ -67,18 +68,25 @@ class StandinHeaderinator
     end
   end
 
-  # Gives the mock's mirrored directory, or nil when its missing header is tolerated or
-  # the test has no mock root
+  # Gives the search paths that reach the mock, or nil when its missing header is tolerated
+  # or the test has no mock root
   def place_mock(testable, include, collection, complain)
+    return nil if testable.paths[:mocks].nil?
+
     source, subdir = @mock_locator.locate( include, collection: collection, complain: complain )
     return nil if source.nil?
 
-    mock_dir = subdir.empty? ? testable.name : File.join( testable.name, subdir )
-    write_mock( testable.name, @file_path_utils.form_mock_header_filepath( mock_dir, include.filename ), include, source )
+    placement = @mock_locator.placement( mocks_root: testable.paths[:mocks], subdir: subdir, include_path: include.filepath )
+    write_placed_mock( testable.name, placement, include, source )
 
-    return nil if testable.paths[:mocks].nil?
+    return @mock_locator.search_directories( placement )
+  end
 
-    return @file_path_utils.form_mock_output_path( testable.paths[:mocks], subdir )
+  # The test's #include reaches a climbing folder's mock only from the directory it climbs
+  # from, so that is made too
+  def write_placed_mock(test, placement, include, source)
+    @file_wrapper.mkdir( placement.reach ) unless ProjectPaths.contains?( placement.reach, placement.directory )
+    write_mock( test, File.join( placement.directory, include.filename.ext( EXTENSION_CORE_HEADER ) ), include, source, placement.folder )
   end
 
   # A Partial's generated #include names whatever directory its module was named by, and
@@ -97,8 +105,8 @@ class StandinHeaderinator
     @file_wrapper.write_blank_file( filepath )
   end
 
-  def write_mock(test, filepath, include, header)
-    contents = "#{MARKER}\n#{header_include( header )}\n"
+  def write_mock(test, filepath, include, header, folder)
+    contents = "#{MARKER}\n#{header_include( header, folder )}\n"
     return if current?( filepath, contents )
 
     log_placement( test, include )
@@ -106,11 +114,12 @@ class StandinHeaderinator
     @file_wrapper.write( filepath, contents )
   end
 
-  # The line CMock opens a mock with: its :orig_header_include_fmt around the header's name.
-  # Ceedling hands CMock no folder, so the name is the header's own.
-  def header_include( header )
+  # The line CMock opens a mock with: its :orig_header_include_fmt around the header's name,
+  # below the folder CMock is given, if any
+  def header_include( header, folder )
     format = @configurator.get_cmock_config[:orig_header_include_fmt] || '#include "%s"'
-    return format.gsub( '%s', File.basename( header ) )
+    name   = folder.nil? ? File.basename( header ) : File.join( folder, File.basename( header ) )
+    return format.gsub( '%s', name )
   end
 
   # A file that is not a stand-in, such as a real mock, counts as current. Only its first

data/lib/ceedling/test_invoker/test_build_executor.rb

@@ -29,7 +29,9 @@ class TestBuildExecutor
     :dependinator,
     :gcc_dependency_parser,
     :quote_include_isolator,
-    :generator_helper
+    :generator_helper,
+    :library_resolver,
+    :mock_locator
   )
 
   # Stage 9: Preprocess header files to be mocked.
@@ -148,9 +150,10 @@ class TestBuildExecutor
       details  = mock.details
       testable = mock.testable
 
-      output_path = @file_path_utils.form_mock_output_path( testable.paths[:mocks], details.path )
-      folder, output_path = mock_folder_and_path( testable.paths[:mocks], output_path, details.include_path )
-      @file_wrapper.mkdir( output_path )
+      placement   = @mock_locator.placement( mocks_root: testable.paths[:mocks], subdir: details.path, include_path: details.include_path )
+      output_path = placement.directory
+      # The compiler reaches a climbing folder's mock only through CMock's root
+      @mock_locator.search_directories( placement ).each { |dir| @file_wrapper.mkdir( dir ) }
 
       # `details.input` -- not the stage 9 preprocessed target -- is the
       # correct antecedent here: it's exactly what CMock reads, whether or not
@@ -191,7 +194,8 @@ class TestBuildExecutor
         test:           testable.name,
         input_filepath: details.input,
         output_path:    output_path,
-        folder:         folder,
+        mock_root:      placement.root,
+        folder:         placement.folder,
         overrides:      overrides
       }
 
@@ -278,7 +282,8 @@ class TestBuildExecutor
   # Stage 16: Link test executables.
   def stage_build_executables(state)
     lib_args  = convert_libraries_to_arguments()
-    lib_paths = get_library_paths_to_arguments()
+    lib_paths = @library_resolver.search_path_arguments()
+    libraries = @library_resolver.link_files( test_library_entries() )
     skipped = 0
 
     @batchinator.exec(workload: :compile, things: state.testables) do |_, testable|
@@ -287,10 +292,14 @@ class TestBuildExecutor
       link_flags = testable.link_flags
       tool, link_flags = resolve_link_tool( context: state.context, tool: @configurator.tools_test_linker, flags: link_flags, executable: testable.executable )
 
+      # Staleness checks only the files registered here, so an object or library dropped from
+      # the link (a source deleted, excluded, or moved out of the configured paths) changes
+      # nothing they see. The object and library lists as meta do change.
+      objects = testable.objects.to_a
       @dependinator.register(
         testable.executable,
-        files: testable.objects,
-        meta:  { flags: link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [tool] }
+        files: objects + libraries,
+        meta:  { flags: link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [tool], objects: objects, libraries: libraries }
       )
       stale = @dependinator.stale?( testable.executable )
 
@@ -350,6 +359,11 @@ class TestBuildExecutor
   # (not reusing it) so a tool-only change reruns the fixture without also
   # marking the executable itself stale and forcing an unnecessary relink.
   #
+  # The command line test case filters (--test-case, --exclude_test_case) are a fourth.
+  # When :test_runner ↳ :cmdline_args is on, as any :use_backtrace other than :none makes
+  # it, a filtered and an unfiltered executable are identical, and only the filter tells
+  # one run's results from another's. See fixture_meta.
+  #
   # The target itself is a dedicated marker file, not either outcome-dependent
   # results file (.pass/.fail) -- which of those two actually gets written
   # depends on whether the test passes, so neither is guaranteed to exist after
@@ -375,11 +389,9 @@ class TestBuildExecutor
 
     @batchinator.exec(workload: :test, things: state.testables) do |_, testable|
       begin
-        # `paths[:results]` is only per-test-unique for a test mirrored into its own
-        # subdirectory -- a test with no mirrored subdir shares that directory with
-        # every other such test, so the marker's own filename (not just its directory)
-        # must be test-specific too, matching clean_test_results' own `test + '.*'`
-        # naming below.
+        # `paths[:results]` is the directory of the test's name, which every test beside
+        # it shares, so the marker's own filename must be test-specific too, matching
+        # clean_test_results' own `test + '.*'` naming below.
         fixture_target = File.join( testable.paths[:results], "#{File.basename( testable.name )}.fixture_run" )
 
         fixture_tool = resolve_fixture_tool( context: state.context, tool: @configurator.tools_test_fixture, test_name: testable.name, target: fixture_target )
@@ -404,7 +416,7 @@ class TestBuildExecutor
 
         @dependinator.register(
           fixture_target, files: [testable.executable],
-          meta: { tools: [fixture_tool], use_backtrace: use_backtrace, backtrace_tools: backtrace_tools }
+          meta: fixture_meta( fixture_tool: fixture_tool, use_backtrace: use_backtrace, backtrace_tools: backtrace_tools )
         )
 
         run_now = testable.executable_rebuilt || force_rerun || @dependinator.stale?( fixture_target )
@@ -466,6 +478,18 @@ class TestBuildExecutor
   # Helper methods
   # -----------------------------------------------------------------------
 
+  # What a test fixture's run depends on besides its executable. An unset filter, nil or
+  # empty, is one value, so an unfiltered run keeps a stable key.
+  def fixture_meta(fixture_tool:, use_backtrace:, backtrace_tools:)
+    return {
+      tools:             [fixture_tool],
+      use_backtrace:     use_backtrace,
+      backtrace_tools:   backtrace_tools,
+      include_test_case: @configurator.include_test_case.to_s,
+      exclude_test_case: @configurator.exclude_test_case.to_s
+    }
+  end
+
   def generate_executable(context:, build_path:, executable:, objects:, flags:, lib_args:, lib_paths:, tool:)
     begin
       @generator.generate_executable_file(
@@ -529,41 +553,18 @@ class TestBuildExecutor
   end
 
   def convert_libraries_to_arguments()
-    args = ((@configurator.project_config_hash[:libraries_test] || []) + ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])).flatten
+    args = test_library_entries()
     if (defined? LIBRARIES_FLAG)
       args.map! { |v| LIBRARIES_FLAG.gsub( /\$\{1\}/, v ) }
     end
     return args
   end
 
-  def get_library_paths_to_arguments()
-    paths = (defined? PATHS_LIBRARIES) ? (PATHS_LIBRARIES || []).clone : []
-    if (defined? LIBRARIES_PATH_FLAG)
-      paths.map! { |v| LIBRARIES_PATH_FLAG.gsub( /\$\{1\}/, v ) }
-    end
-    return paths
-  end
-
   private
 
-  # Finds the folder a mock's #include names and the directory the mock is written to.
-  #
-  # CMock names a mock's guard and lifecycle functions by that folder, and the runner names
-  # its calls by the same #include. Two same-named mocks stay distinct only if the folder
-  # reaches CMock. CMock writes below its own root at that folder, so the folder must end the
-  # mock's directory. A folder trailing the mirrored location keeps that location. An #include
-  # spelling more path than the mirror holds moves its mock below the per-test root at the
-  # written path, which the root search path still reaches. A bare #include has no folder.
-  # Without :mock_name_include_folder no folder is passed, and CMock names by filename alone.
-  def mock_folder_and_path(mocks_root, output_path, include_path)
-    return [nil, output_path] unless @configurator.cmock_mock_name_include_folder
-
-    folder = File.dirname( include_path.to_s ).sub( %r{\A(?:\./)+}, '' )
-
-    return [nil, output_path] if folder.empty? || folder == '.'
-    return [folder, output_path] if output_path.end_with?( File.join( '', folder ) )
-
-    return [folder, File.join( mocks_root, folder )]
+  # The :libraries entries a test links, whatever form each takes
+  def test_library_entries()
+    return ((@configurator.project_config_hash[:libraries_test] || []) + ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])).flatten
   end
 
   # Compile a single C or assembly source file into an object file. Returns

data/lib/ceedling/test_invoker/test_build_planner.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
+require 'ceedling/filesystem/project_paths'
 require 'ceedling/test_invoker/test_invoker_types'
 require 'ceedling/test_invoker/test_pipeline_helpers'
 require 'ceedling/test_invoker/test_build_validations'
@@ -48,6 +49,10 @@ class TestBuildPlanner
       mocks   = {}
       _mocks  = @context_extractor.lookup_mock_header_includes_list( filepath )
 
+      # Built at the first real mock and shared by the rest, since nothing here changes
+      # this test's search paths
+      collection = nil
+
       _mocks.each do |include|
         name    = File.basename( include.filename ).ext()
         source  = nil
@@ -60,7 +65,8 @@ class TestBuildPlanner
           input  = source
           subdir = partial_mock_subdir( include )
         else
-          source, subdir     = @mock_locator.locate( include, collection: ordered_mock_header_collection( testable ) )
+          collection       ||= ordered_mock_header_collection( testable )
+          source, subdir     = @mock_locator.locate( include, collection: collection )
           preprocessed_input = @file_path_utils.form_preprocessed_file_filepath( source, test )
           input             = (@configurator.project_use_test_preprocessor_mocks ? preprocessed_input : source)
         end
@@ -72,11 +78,11 @@ class TestBuildPlanner
         # the mock stays findable by the compiler regardless
         # of how much path the #include itself happened to spell out.
         #
-        # Keyed by that directory alongside the name. Two modules sharing a basename are
-        # two modules, each needing its own mock, and a key of the name alone lets the
-        # second displace the first. `name` stays bare: it is the filename the mock is
-        # written under, joined with `path` at generation.
-        mocks[mock_key( name, subdir )] = MockDetails.new(
+        # Keyed by the directory the mock is written to alongside the name. Two modules
+        # sharing a basename are two modules, each needing its own mock, and a key of the
+        # name alone lets the second displace the first. `name` stays bare: it is the
+        # filename the mock is written under, at generation.
+        mocks[mock_key( name, partial ? subdir : placed_subdir( testable, subdir, include ) )] = MockDetails.new(
           name:     name,
           filepath: source,
           path:     subdir,
@@ -185,7 +191,7 @@ class TestBuildPlanner
       test_no_link_objects =
         @file_path_utils.form_test_build_objects_filelist(
           testable.paths[:build],
-          fetch_shallow_source_includes( filepath ),
+          fetch_shallow_source_includes( filepath, state.context, testable.name ),
           extra_roots: generated_roots
         )
 
@@ -237,10 +243,11 @@ class TestBuildPlanner
     sources << File.join( PROJECT_BUILD_VENDOR_CEXCEPTION_PATH, CEXCEPTION_C_FILE ) if @configurator.project_use_exceptions
 
     if @configurator.project_use_mocks
+      # :unity_helper_path names a helper's header, or its path without an extension. The
+      # source beside it is what compiles.
       @configurator.cmock_unity_helper_path.each do |helper|
-        if @file_wrapper.exist?( helper.ext( EXTENSION_SOURCE.primary ) )
-          sources << helper
-        end
+        source = helper.ext( EXTENSION_SOURCE.primary )
+        sources << source if @file_wrapper.exist?( source )
       end
     end
 
@@ -313,8 +320,12 @@ class TestBuildPlanner
     )
   end
 
-  def fetch_shallow_source_includes(test_filepath)
-    return @test_context_extractor.lookup_source_includes_list( test_filepath )
+  # The sources a test #includes, which it must not link a second time. Each is the file its
+  # #include names, since that file's object sits at its own path, not the #include's.
+  def fetch_shallow_source_includes(test_filepath, context, test_name)
+    return @test_context_extractor.lookup_source_includes_list( test_filepath ).map do |include|
+      @file_finder.find_build_input_file( filepath: include.filepath, complain: :ignore, context: context, test: test_name ) || include.filepath
+    end
   end
 
   # Every stage resolving a mock's real header must agree on the same winner, or a
@@ -323,6 +334,16 @@ class TestBuildPlanner
     @mock_locator.header_collection( testable.search_paths, testable.mock_search_paths )
   end
 
+  # The mock's directory below its test's mock root, where generation writes it. Two
+  # same-named headers may mirror alike and differ only by the folders their #includes name.
+  def placed_subdir(testable, subdir, include)
+    root = testable.paths[:mocks]
+    return subdir if root.nil?
+
+    placement = @mock_locator.placement( mocks_root: root, subdir: subdir, include_path: include.filepath )
+    return ProjectPaths.subdir_below( root, placement.directory ) || subdir
+  end
+
   # One mock's identity within its test. A mock directly in the mock root keeps the bare
   # name it has always had, so nothing changes for a project without same-named mocks.
   def mock_key(name, subdir)
@@ -331,8 +352,8 @@ class TestBuildPlanner
     return File.join( subdir, name ).to_sym
   end
 
-  # Each mock's own generated source, below this test's mock root in the subdirectory
-  # mirroring whatever it mocks -- the same place mock generation writes it.
+  # Each mock's own generated source, below this test's mock root where mock generation
+  # writes it (MockLocator#placement)
   #
   # Named by its own path rather than its basename so two same-named mocks in one test
   # stay distinct, and so each one's object mirrors that subdirectory too.
@@ -342,10 +363,8 @@ class TestBuildPlanner
     return [] if root.nil?
 
     testable.mocks.each_value.map do |details|
-      File.join(
-        @file_path_utils.form_mock_output_path( root, details.path ),
-        details.name + EXTENSION_CORE_SOURCE
-      )
+      placement = @mock_locator.placement( mocks_root: root, subdir: details.path, include_path: details.include_path )
+      File.join( placement.directory, details.name + EXTENSION_CORE_SOURCE )
     end
   end
 

data/lib/ceedling/test_invoker/test_build_setup.rb

@@ -13,7 +13,6 @@ require 'ceedling/partials/partials'
 require 'ceedling/test_invoker/test_invoker_types'
 require 'ceedling/test_invoker/test_pipeline_helpers'
 require 'ceedling/test_invoker/test_build_validations'
-require 'ceedling/path_mirror'
 
 class TestBuildSetup
 
@@ -36,7 +35,8 @@ class TestBuildSetup
     :test_runner_manager,
     :dependinator,
     :test_search_paths,
-    :mock_locator
+    :mock_locator,
+    :test_source_file_directive_resolver
   )
 
   def setup()
@@ -44,14 +44,15 @@ class TestBuildSetup
   end
 
   # Stage 1: Create per-test build/results/mock/partial directory structure
-  # and populate the testables hash with initial entries.
+  # and populate the testables hash with initial entries. Stops first if two
+  # tests in the build share a name.
   def stage_prepare_build_paths(state)
-    clean_test_roots = PathMirror.clean_roots( @configurator.paths_test )
+    validate_unique_test_names!( tests: state.tests )
 
     @batchinator.exec(workload: :compile, things: state.tests) do |filepath|
       filepath = filepath.to_s
-      key  = testable_symbolize( filepath, clean_test_roots )
-      name = key.to_s
+      name = @file_path_utils.form_test_name( filepath )
+      key  = name.to_sym
 
       state.lock.synchronize do
         state.testables[key] = Testable.new(
@@ -114,8 +115,10 @@ class TestBuildSetup
       filepath = testable.filepath
       filename = File.basename( filepath )
 
+      # Only a scan without test preprocessing finds TEST_SOURCE_FILE() entries, so a cache
+      # from the other mode is stale
       cache_target = @file_path_utils.form_test_build_directives_cache_filepath( filepath, testable.name )
-      @dependinator.register( cache_target, files: [filepath] )
+      @dependinator.register( cache_target, files: [filepath], meta: { source_files_scanned: !@configurator.project_use_test_preprocessor_tests } )
       directives_stale = @dependinator.stale?( cache_target )
 
       contexts = [TestContextExtractor::Context::INCLUDES]
@@ -167,6 +170,8 @@ class TestBuildSetup
         state.lock.synchronize { skipped += 1 }
       end
 
+      validate_source_file_directives( testable, state.context )
+
       validate_mocks_in_use(
         filename: filename,
         mocks:    @context_extractor.lookup_mock_header_includes_list( filepath )
@@ -321,12 +326,12 @@ class TestBuildSetup
 
   private
 
-  def testable_symbolize(filepath, clean_roots)
-    basename = File.basename( filepath ).ext( '' )
-    subdir   = PathMirror.relative_subdir_from_clean_roots( filepath, clean_roots )
-    name     = subdir.empty? ? basename : File.join( subdir, basename )
+  # Without test preprocessing, stage 11 never runs, and only stage 2's scan finds a test's
+  # TEST_SOURCE_FILE() entries
+  def validate_source_file_directives(testable, context)
+    return if @configurator.project_use_test_preprocessor_tests
 
-    return name.to_sym
+    @test_source_file_directive_resolver.validate!( test: testable.name, test_filepath: testable.filepath, context: context )
   end
 
 end

data/lib/ceedling/test_invoker/test_build_validations.rb

@@ -5,15 +5,29 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'ceedling/filesystem/destination_collision'
+
 # Test-build configuration validators shared by more than one test pipeline stage
 # class -- each raises CeedlingException on a real, user-facing mistake it's
-# positioned to catch (a project using mocking, Partials, or a build-directive
-# source without configuring for it, or a header that doesn't actually resolve).
+# positioned to catch (a project using mocking or Partials without configuring for
+# it, a header that doesn't actually resolve, or two tests sharing one name).
 # Relies on whichever including class's own constructor DI already provides the
 # collaborators a given validator needs, the same way TestPipelineHelpers is
 # mixed in without any DI wiring of its own.
 module TestBuildValidations
 
+  # A name is its test's path without its extension, so two tests share one only when they
+  # differ in extension alone (`test_a.c` and `test_a.cpp`). Sharing would silently drop one
+  # test, so a build with them in it stops. A build without them is unaffected.
+  def validate_unique_test_names!(tests:)
+    shared = DestinationCollision.find( @configurator.collection_all_tests.map( &:to_s ) ) { |test| @file_path_utils.form_test_name( test ) }
+
+    tests.each do |test|
+      name = @file_path_utils.form_test_name( test )
+      DestinationCollision.raise_for( name, shared[name], 'share the build name' ) if shared.key?( name )
+    end
+  end
+
   def validate_mocks_in_use(filename:, mocks:)
     if !@configurator.project_use_mocks and !mocks.empty?
       _mocks = mocks.map { |include| include.filename }
@@ -70,33 +84,4 @@ module TestBuildValidations
     end
   end
 
-  # A TEST_SOURCE_FILE() entry must name a real, recognized file whether it
-  # adds or removes -- a typo or a nonexistent path is worth failing loudly
-  # on either side of the +:/-: convention, the same way a missing file has
-  # always been treated for a plain, additive entry.
-  def validate!(test:, filepath:)
-    sources = @test_context_extractor.lookup_build_directive_sources_list( filepath )
-
-    ext_message = @configurator.extension_source.to_s
-    ext_message += " or #{@configurator.extension_assembly}" if @configurator.test_build_use_assembly
-
-    sources.each do |raw_source|
-      source = FilePathUtils.no_aggregation_decorators( raw_source )
-      valid_extension =
-        if @configurator.test_build_use_assembly
-          @configurator.extension_assembly.match?( source ) || @configurator.extension_source.match?( source )
-        else
-          @configurator.extension_source.match?( source )
-        end
-
-      unless valid_extension
-        raise CeedlingException.new( "File '#{source}' specified with TEST_SOURCE_FILE() in #{test} is not a #{ext_message} source file" )
-      end
-
-      if @file_finder.find_build_input_file( filepath: source, complain: :ignore, context: TEST_SYM ).nil?
-        raise CeedlingException.new( "File '#{source}' specified with TEST_SOURCE_FILE() in #{test} cannot be found in the source file collection" )
-      end
-    end
-  end
-
 end

data/lib/ceedling/test_invoker/test_file_preprocessinator.rb

@@ -50,7 +50,7 @@ class TestFilePreprocessinator
       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 ) }
+      @test_source_file_directive_resolver.validate!( test: testable.name, test_filepath: testable.filepath, context: state.context )
     end
 
     log_skip_summary( task: "test file preprocessing", count: skipped, noun: "test files" )

data/lib/ceedling/test_invoker/test_invoker.rb

@@ -22,7 +22,8 @@ class TestInvoker
     :dependinator,
     :loginator,
     :verbosinator,
-    :test_pipeline_manager
+    :test_pipeline_manager,
+    :include_pathinator
   )
 
   def setup
@@ -40,6 +41,10 @@ class TestInvoker
     timestamp_s = SystemWrapper.time_stopwatch_s()
     @plugin_manager.pre_test_build( context, timestamp_s )
 
+    # After the hook, so a header it writes is listed, and once per run, so a later run in
+    # the same process lists every search path afresh
+    @include_pathinator.forget_header_listings
+
     # `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

data/lib/ceedling/test_invoker/test_pipeline_helpers.rb

@@ -5,7 +5,7 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
 
 # Small helpers shared by more than one test pipeline stage class. Relies on
 # `@reportinator`/`@loginator` already being present via whichever including