ceedling 1.2.0 → 1.2.2

data/spec/units/test_build_planner_spec.rb

@@ -25,6 +25,8 @@ EXTENSION_HEADER       = FilenameExtension.new('.h')  unless defined?(EXTENSION_
 describe TestBuildPlanner do
   before(:each) do
     @configurator           = double( "Configurator" )
+    # Ceedling always defaults it, and the mock locator reads it
+    allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( true )
     @loginator               = double( "Loginator" )
     @reportinator             = double( "Reportinator" )
     @batchinator               = double( "Batchinator" )
@@ -167,6 +169,7 @@ describe TestBuildPlanner do
 
     context "with a non-Partial mocked header" do
       before(:each) do
+        allow(@file_path_utils).to receive(:form_mock_output_path) { |root, subdir| subdir.to_s.empty? ? root : File.join( root, subdir ) }
         mock = MockInclude.new( 'MockFoo.h' )
         allow(@test_context_extractor).to receive(:lookup_mock_header_includes_list)
           .with( 'test/TestFoo.c' ).and_return( [mock] )
@@ -204,6 +207,45 @@ describe TestBuildPlanner do
       end
     end
 
+    # Two headers directly in two include roots mirror alike, and only their #include
+    # folders tell their mocks apart
+    it "keeps two same-named mocks whose #include folders alone differ" do
+      allow(@test_context_extractor).to receive(:lookup_mock_header_includes_list)
+        .with( 'test/TestFoo.c' ).and_return( [MockInclude.new( 'a/MockFoo.h' ), MockInclude.new( 'b/MockFoo.h' )] )
+      allow(@configurator).to receive(:cmock_mock_prefix).and_return( 'Mock' )
+      allow(@configurator).to receive(:project_use_test_preprocessor_mocks).and_return( false )
+      allow(@file_finder).to receive(:resolve_mock).with( 'a/MockFoo.h', collection: [], complain: :error ).and_return( ['inc/a/foo.h', ''] )
+      allow(@file_finder).to receive(:resolve_mock).with( 'b/MockFoo.h', collection: [], complain: :error ).and_return( ['inc/b/foo.h', ''] )
+      allow(@file_path_utils).to receive(:form_preprocessed_file_filepath).and_return( 'unused' )
+
+      @planner.stage_determine_files( @state )
+
+      expect(@testable.mocks.keys).to contain_exactly( :'a/MockFoo', :'b/MockFoo' )
+      expect(@testable.mocks.values.map( &:source )).to contain_exactly( 'inc/a/foo.h', 'inc/b/foo.h' )
+    end
+
+    # Nothing in the loop over a test's mocks changes its search paths, so one collection
+    # serves every mock. Validation lists the whole search paths, mock directories included.
+    it "builds one mock header collection for all of a test's real mocks" do
+      mocks = %w[MockFoo.h MockBar.h MockBaz.h].map { |name| MockInclude.new( name ) }
+      allow(@test_context_extractor).to receive(:lookup_mock_header_includes_list).with( 'test/TestFoo.c' ).and_return( mocks )
+      allow(@configurator).to receive(:cmock_mock_prefix).and_return( 'Mock' )
+      allow(@configurator).to receive(:project_use_test_preprocessor_mocks).and_return( false )
+      allow(@file_finder).to receive(:resolve_mock) { |mock, **| ["src/#{mock.delete_prefix( 'Mock' )}", ''] }
+      allow(@file_path_utils).to receive(:form_preprocessed_file_filepath).and_return( 'unused' )
+      allow(@file_path_utils).to receive(:form_mock_output_path) { |root, subdir| subdir.to_s.empty? ? root : File.join( root, subdir ) }
+      @testable.search_paths      = ['build/test/mocks/a_test', 'src']
+      @testable.mock_search_paths = ['build/test/mocks/a_test']
+
+      collections = 0
+      allow(@include_pathinator).to receive(:ordered_header_files).with( ['src'] ) { collections += 1; ['src/Foo.h'] }
+
+      @planner.stage_determine_files( @state )
+
+      expect(@testable.mocks.length).to eq( 3 )
+      expect(collections).to eq( 1 )
+    end
+
     context "with a Partial mocked header" do
       before(:each) do
         mock = MockInclude.new( 'Mockceedling_partial_foo_interface.h' )
@@ -217,6 +259,15 @@ describe TestBuildPlanner do
 
       # A Partial mock has no real header to resolve against, so its directory comes
       # from the generated #include rather than from a mirrored source location.
+      it "builds no mock header collection, having no real header to resolve" do
+        @testable.search_paths      = ['build/test/mocks/a_test', 'src']
+        @testable.mock_search_paths = ['build/test/mocks/a_test']
+
+        expect(@include_pathinator).to_not receive(:ordered_header_files).with( ['src'] )
+
+        @planner.stage_determine_files( @state )
+      end
+
       it "stays flat when its generated #include names no directory" do
         expect(@file_finder).to_not receive(:resolve_mock)
 
@@ -431,6 +482,23 @@ describe TestBuildPlanner do
       expect( captured ).to include('build/test/mocks/a_test/drivers/spi/Mockconfig.c')
     end
 
+    it "compiles a mock whose #include folder climbs from where it is written, below the mock root" do
+      allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( true )
+      @testable.mocks = {
+        :'x/Mockconfig' => TestInvokerTypes::MockDetails.new( name: 'Mockconfig', path: 'x', partial: false, include_path: '../x/Mockconfig.h' )
+      }
+
+      captured = nil
+      allow(@file_path_utils).to receive(:form_test_build_objects_filelist) do |_path, files, **_kw|
+        captured ||= files
+        []
+      end
+
+      @planner.stage_determine_artifacts( @state )
+
+      expect( captured ).to include('build/test/mocks/a_test/_up_/x/Mockconfig.c')
+    end
+
     # A mock and a generated Partial both sit below their own generated root rather than a
     # configured source root, so nothing in the standard roots mirrors them. Without those
     # roots, two same-named mocks or modules collapse onto one object filename.
@@ -484,7 +552,9 @@ describe TestBuildPlanner do
         allow(@test_source_file_directive_resolver).to receive(:resolve)
           .with( 'test/TestFoo.c', :test ).and_return( [['src/Foo.c'], {}] )
         allow(@test_context_extractor).to receive(:lookup_source_includes_list)
-          .with( 'test/TestFoo.c' ).and_return( ['src/Foo.c'] )
+          .with( 'test/TestFoo.c' ).and_return( [UserInclude.new( 'src/Foo.c' )] )
+        allow(@file_finder).to receive(:find_build_input_file)
+          .with( filepath: 'src/Foo.c', complain: :ignore, context: :test, test: 'a_test' ).and_return( 'src/Foo.c' )
       end
 
       it "resolves it as a source to compile but excludes its object from what gets linked" do
@@ -494,6 +564,25 @@ describe TestBuildPlanner do
         expect(@testable.objects).to_not include( 'src/Foo.o' )
       end
     end
+
+    # A test #includes a source by the name its own #include spells, and that source's object
+    # sits at the source's path, not the #include's
+    context "when a test #includes a source by its name alone" do
+      before(:each) do
+        allow(@test_source_file_directive_resolver).to receive(:resolve)
+          .with( 'test/TestFoo.c', :test ).and_return( [['src/Foo.c'], {}] )
+        allow(@test_context_extractor).to receive(:lookup_source_includes_list)
+          .with( 'test/TestFoo.c' ).and_return( [UserInclude.new( 'Foo.c' )] )
+        allow(@file_finder).to receive(:find_build_input_file)
+          .with( filepath: 'Foo.c', complain: :ignore, context: :test, test: 'a_test' ).and_return( 'src/Foo.c' )
+      end
+
+      it "excludes the object of the source it names from what gets linked" do
+        @planner.stage_determine_artifacts( @state )
+
+        expect(@testable.objects).to_not include( 'src/Foo.o' )
+      end
+    end
   end
 
   describe "#stage_flatten_objects_list" do
@@ -696,7 +785,20 @@ describe TestBuildPlanner do
 
       result = @planner.collect_test_framework_sources( true )
 
-      expect(result).to include( 'test/support/unity_helper' )
+      expect(result).to include( 'test/support/unity_helper.c' )
+    end
+
+    # The path handling audit around GH #1370: :unity_helper_path names the helper's header,
+    # and its source is what compiles
+    it "G25: compiles the source beside a Unity helper named by its header" do
+      allow(@configurator).to receive(:project_use_mocks).and_return( true )
+      allow(@configurator).to receive(:cmock_unity_helper_path).and_return( ['test/support/unity_helper.h'] )
+      allow(@file_wrapper).to receive(:exist?).with( 'test/support/unity_helper.c' ).and_return( true )
+
+      result = @planner.collect_test_framework_sources( true )
+
+      expect(result).to include( 'test/support/unity_helper.c' )
+      expect(result).to_not include( 'test/support/unity_helper.h' )
     end
 
     it "omits a Unity helper source file that doesn't exist on disk" do

data/spec/units/test_build_setup_spec.rb

@@ -14,6 +14,8 @@ require 'ceedling/test_invoker/mock_locator'
 describe TestBuildSetup do
   before(:each) do
     @configurator            = double( "Configurator" )
+    # Ceedling always defaults it, and the mock locator reads it
+    allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( true )
     @loginator               = double( "Loginator" )
     @reportinator            = double( "Reportinator" )
     @batchinator             = double( "Batchinator" )
@@ -66,6 +68,9 @@ describe TestBuildSetup do
     allow(@configurator).to receive(:collection_paths_vendor).and_return( [] )
     allow(@configurator).to receive(:collection_paths_test_toolchain_include).and_return( [] )
 
+    @test_source_file_directive_resolver = double( "TestSourceFileDirectiveResolver" )
+    allow(@test_source_file_directive_resolver).to receive(:validate!)
+
     @mock_locator = MockLocator.new(
       configurator: @configurator, include_pathinator: @include_pathinator, file_finder: @file_finder, file_path_utils: @file_path_utils
     )
@@ -89,7 +94,8 @@ describe TestBuildSetup do
         :test_search_paths      => TestSearchPaths.new(
           configurator: @configurator, include_pathinator: @include_pathinator, test_context_extractor: @test_context_extractor
         ),
-        :mock_locator           => @mock_locator
+        :mock_locator           => @mock_locator,
+        :test_source_file_directive_resolver => @test_source_file_directive_resolver
       }
     )
 
@@ -119,15 +125,17 @@ describe TestBuildSetup do
       allow(@file_path_utils).to receive(:form_test_preprocess_files_directives_only_path).and_return( 'build/test/preprocess/directives/a_test' )
       allow(@file_path_utils).to receive(:form_test_preprocess_files_raw_directives_only_path).and_return( 'build/test/preprocess/raw/a_test' )
       allow(@file_path_utils).to receive(:form_test_preprocess_build_directives_path).and_return( 'build/test/preprocess/build_directives/a_test' )
+      allow(@file_path_utils).to receive(:form_test_name) { |filepath| filepath.to_s.ext( '' ).sub( '../', '_up_/' ) }
       allow(@file_wrapper).to receive(:mkdir)
+      allow(@configurator).to receive(:collection_all_tests).and_return( ['test/TestFoo.c'] )
       allow(@configurator).to receive(:project_use_mocks).and_return( false )
       allow(@configurator).to receive(:project_use_partials).and_return( false )
       allow(@configurator).to receive(:project_use_test_preprocessor).and_return( :none )
     end
 
-    def prepare_state
+    def prepare_state(tests = ['test/TestFoo.c'])
       TestInvokerTypes::PipelineState.new(
-        :tests => ['test/TestFoo.c'], :testables => {}, :context => :test, :options => [], :lock => Mutex.new
+        :tests => tests, :testables => {}, :context => :test, :options => [], :lock => Mutex.new
       )
     end
 
@@ -136,9 +144,53 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      testable = state.testables[:TestFoo]
+      testable = state.testables[:"test/TestFoo"]
       expect(testable.filepath).to eq( 'test/TestFoo.c' )
-      expect(testable.name).to eq( 'TestFoo' )
+      expect(testable.name).to eq( 'test/TestFoo' )
+    end
+
+    # GH #1364: same-named tests at a root and below it
+    it "keeps same-named tests apart by their names" do
+      tests = ['test/test_calc.c', 'test/unit/test_calc.c']
+      allow(@configurator).to receive(:collection_all_tests).and_return( tests )
+      state = prepare_state( tests )
+
+      @setup.stage_prepare_build_paths( state )
+
+      expect(state.testables.keys).to contain_exactly( :'test/test_calc', :'test/unit/test_calc' )
+      expect(state.testables.values.map(&:filepath)).to contain_exactly( *tests )
+    end
+
+    # Two configured source extensions let one stem name two test files
+    it "stops a build with two test files differing only in extension, naming both" do
+      allow(@configurator).to receive(:collection_all_tests).and_return( ['test/test_a.c', 'test/test_a.cpp'] )
+
+      expect { @setup.stage_prepare_build_paths( prepare_state( ['test/test_a.c'] ) ) }.to raise_error( CeedlingException ) { |error|
+        expect(error.message).to include( 'test/test_a.c', 'test/test_a.cpp', '`test/test_a`' )
+      }
+    end
+
+    context "when two tests map to one name" do
+      before(:each) do
+        allow(@configurator).to receive(:collection_all_tests).and_return( ['../x/test_a.c', '_up_/x/test_a.c', 'test/test_b.c'] )
+      end
+
+      it "stops before making any directory or testable, naming both files" do
+        state = prepare_state( ['_up_/x/test_a.c'] )
+
+        expect(@file_wrapper).to_not receive(:mkdir)
+        expect { @setup.stage_prepare_build_paths( state ) }.to raise_error( CeedlingException ) { |error|
+          expect(error.message).to include( '../x/test_a.c', '_up_/x/test_a.c', '`_up_/x/test_a`' )
+        }
+        expect(state.testables).to be_empty
+      end
+
+      it "lets a build go ahead when neither test is in it" do
+        state = prepare_state( ['test/test_b.c'] )
+
+        expect { @setup.stage_prepare_build_paths( state ) }.to_not raise_error
+        expect(state.testables.keys).to eq( [:'test/test_b'] )
+      end
     end
 
     it "always assembles the build, results, dependencies, and runners paths" do
@@ -146,7 +198,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      paths = state.testables[:TestFoo].paths
+      paths = state.testables[:"test/TestFoo"].paths
       expect(paths[:build]).to eq( 'build/test/out/a_test' )
       expect(paths[:results]).to eq( 'build/test/results/a_test' )
       expect(paths[:dependencies]).to eq( 'build/test/dependencies/a_test' )
@@ -159,7 +211,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      expect(state.testables[:TestFoo].paths).to_not have_key( :mocks )
+      expect(state.testables[:"test/TestFoo"].paths).to_not have_key( :mocks )
     end
 
     it "assembles the mocks path when the project has mocking enabled" do
@@ -168,7 +220,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      expect(state.testables[:TestFoo].paths[:mocks]).to eq( 'build/test/mocks/a_test' )
+      expect(state.testables[:"test/TestFoo"].paths[:mocks]).to eq( 'build/test/mocks/a_test' )
     end
 
     it "omits the partials path when the project has Partials disabled" do
@@ -176,7 +228,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      expect(state.testables[:TestFoo].paths).to_not have_key( :partials )
+      expect(state.testables[:"test/TestFoo"].paths).to_not have_key( :partials )
     end
 
     it "assembles the partials path when the project has Partials enabled" do
@@ -185,7 +237,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      expect(state.testables[:TestFoo].paths[:partials]).to eq( 'build/test/partials/a_test' )
+      expect(state.testables[:"test/TestFoo"].paths[:partials]).to eq( 'build/test/partials/a_test' )
     end
 
     it "omits the preprocessing paths and scratch state when preprocessing is off" do
@@ -193,7 +245,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      testable = state.testables[:TestFoo]
+      testable = state.testables[:"test/TestFoo"]
       expect(testable.paths).to_not have_key( :preprocess_includes )
       expect(testable.preprocess).to_not have_key( :includes )
     end
@@ -204,7 +256,7 @@ describe TestBuildSetup do
 
       @setup.stage_prepare_build_paths( state )
 
-      testable = state.testables[:TestFoo]
+      testable = state.testables[:"test/TestFoo"]
       expect(testable.paths[:preprocess_includes]).to eq( 'build/test/preprocess/includes/a_test' )
       expect(testable.paths[:preprocess_files]).to eq( 'build/test/preprocess/files/a_test' )
       expect(testable.paths[:preprocess_files_full_expansion]).to eq( 'build/test/preprocess/full/a_test' )
@@ -312,6 +364,38 @@ describe TestBuildSetup do
 
         @setup.stage_collect_test_context( @state )
       end
+
+      # Stage 11, which checks entries otherwise, does not run without test preprocessing
+      it "checks each test's TEST_SOURCE_FILE() entries once, under its own name, scanned or cached" do
+        expect(@test_source_file_directive_resolver).to receive(:validate!).with( test: 'a_test', test_filepath: 'test/TestFoo.c', context: :test ).twice
+
+        [true, false].each do |stale|
+          allow(@dependinator).to receive(:stale?).and_return( stale )
+          @setup.stage_collect_test_context( @state )
+        end
+      end
+    end
+
+    # Only a scan without test preprocessing caches TEST_SOURCE_FILE() entries, so switching
+    # modes must rescan rather than recall a cache missing them
+    it "caches build directives against the test preprocessing mode that scanned them" do
+      [true, false].each do |preprocessing|
+        allow(@configurator).to receive(:project_use_test_preprocessor_tests).and_return( preprocessing )
+        expect(@dependinator).to receive(:register).with(
+          'build/preprocess/build_directives/a_test/Foo.c.yml', files: ['test/TestFoo.c'], meta: { source_files_scanned: !preprocessing }
+        )
+
+        @setup.stage_collect_test_context( @state )
+      end
+    end
+
+    it "leaves TEST_SOURCE_FILE() entries to stage 11 when test preprocessing is on" do
+      allow(@configurator).to receive(:project_use_test_preprocessor_tests).and_return( true )
+      allow(@dependinator).to receive(:stale?).and_return( true )
+
+      expect(@test_source_file_directive_resolver).to_not receive(:validate!)
+
+      @setup.stage_collect_test_context( @state )
     end
 
     it "logs one summary line stating how many test files' build directives were recalled from cache" do

data/spec/units/test_context_extractor_spec.rb

@@ -124,6 +124,17 @@ describe TestContextExtractor do
     end
   end
 
+  # GH #1370 audit (G10): a TEST_INCLUDE_PATH() spelled another way gave its headers a
+  # second spelling beside the collection's own
+  context "#ingest_build_directive_include_paths" do
+    it "records each path in the one spelling every collection uses" do
+      @extractor.ingest_build_directive_include_paths( "path", ["./include/dir", "include\\other/", File.join( Dir.pwd, "inc" )] )
+
+      expect( @extractor.lookup_include_paths_list( "path" ) ).to eq( ["include/dir", "include/other", "inc"] )
+      expect( @extractor.lookup_all_include_paths ).to eq( ["include/dir", "include/other", "inc"] )
+    end
+  end
+
   context "#store_build_directives_cache and #load_build_directives_cache" do
     it "writes the currently known source files and include paths for a test file to the given cache filepath" do
       @extractor.ingest_build_directive_source_files( "path", ["extra.c"] )
@@ -174,6 +185,20 @@ describe TestContextExtractor do
       expect{ @extractor.collect_context( "path", StringIO.new(), :bad ) }.to raise_error( CeedlingException )
     end
 
+    # A #include in a branch that is off, or a `..` spelling the mock search paths reach, both
+    # build, so a climbing mock #include is read like any other
+    it "resolves a mock #include that climbs with `..` against the test file's directory" do
+      @extractor.collect_context( "test/test_c.c", StringIO.new( "#include \"../x/mock_foo.h\"\n" ), TestContextExtractor::Context::INCLUDES )
+
+      expect( @extractor.lookup_mock_header_includes_list( "test/test_c.c" ) ).to eq( [MockInclude.new( 'x/mock_foo.h' )] )
+    end
+
+    it "keeps a non-mock #include that climbs with `..`, resolved against the test file's directory" do
+      @extractor.collect_context( "test/test_c.c", StringIO.new( "#include \"../inc/x/foo.h\"\n" ), TestContextExtractor::Context::INCLUDES )
+
+      expect( @extractor.lookup_all_header_includes_list( "test/test_c.c" ) ).to eq( [UserInclude.new( 'inc/x/foo.h' )] )
+    end
+
     # collect_context() + lookup_all_header_includes_list() + lookup_mock_header_includes_list()
     it "should extract contents of #include directives" do
       filepath = "path/tests/test_file.c"

data/spec/units/test_file_preprocessinator_spec.rb

@@ -156,10 +156,26 @@ describe TestFilePreprocessinator do
     it "validates a test's TEST_SOURCE_FILE() entries through the resolver, regardless of staleness" do
       allow(@dependinator).to receive(:stale?).and_return( false )
 
-      expect(@test_source_file_directive_resolver).to receive(:validate!).with( test: 'a_test', filepath: 'test/TestFoo.c' )
+      expect(@test_source_file_directive_resolver).to receive(:validate!).with( test: 'a_test', test_filepath: 'test/TestFoo.c', context: :test )
 
       @preprocessinator_stage.preprocess( @state )
     end
+
+    # Each test checks its own entries, not every test's
+    it "validates each test's entries once, under that test's own name" do
+      allow(@dependinator).to receive(:stale?).and_return( false )
+      others = %w[b_test c_test].to_h do |name|
+        [name.to_sym, @testable.dup.tap { |testable| testable.name = name; testable.filepath = "test/#{name}.c" }]
+      end
+      @state.testables.merge!( others )
+
+      checked = []
+      allow(@test_source_file_directive_resolver).to receive(:validate!) { |test:, test_filepath:, context:| checked << [test, test_filepath, context] }
+
+      @preprocessinator_stage.preprocess( @state )
+
+      expect(checked).to contain_exactly( ['a_test', 'test/TestFoo.c', :test], ['b_test', 'test/b_test.c', :test], ['c_test', 'test/c_test.c', :test] )
+    end
   end
 
   # The full expansion reads every header the test reaches, so a change to one of them

data/spec/units/test_includes_extractinator_spec.rb

@@ -18,6 +18,8 @@ require 'ceedling/test_invoker/standin_headerinator'
 describe TestIncludesExtractinator do
   before(:each) do
     @configurator            = double( "Configurator" )
+    # Ceedling always defaults it, and the mock locator reads it
+    allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( true )
     @loginator               = double( "Loginator" )
     @reportinator            = double( "Reportinator" )
     @batchinator             = double( "Batchinator" )
@@ -393,8 +395,10 @@ describe TestIncludesExtractinator do
         allow(@file_wrapper).to receive(:exist?).and_return( false )
         allow(@file_wrapper).to receive(:mkdir)
         allow(@file_wrapper).to receive(:write)
-        allow(@file_path_utils).to receive(:form_mock_header_filepath).and_return( 'build/test/mocks/a_test/MockFoo.h' )
         allow(@file_finder).to receive(:resolve_mock).and_return( ['src/Foo.h', ''] )
+        allow(@file_path_utils).to receive(:form_mock_output_path) { |root, subdir| subdir.to_s.empty? ? root : File.join( root, subdir ) }
+        # A test mocks only when its build mocks, which gives it a mock root
+        @testable.paths = { mocks: 'build/test/mocks/a_test' }
       end
 
       it "places a stand-in for each mock on a freshly extracted bare-includes list" do

data/spec/units/test_invoker/objects_wiring_spec.rb

@@ -19,10 +19,13 @@ describe 'Test pipeline object wiring' do
     test_invoker test_pipeline_manager test_build_setup test_includes_extractinator test_bare_includes_extractinator
     test_includes_preprocessinator test_includes_reconcilinator test_build_planner partials_manager
     test_build_executor test_file_preprocessinator test_runner_generatinator test_search_paths mock_locator
-    standin_headerinator
-  ].each do |name|
+    standin_headerinator test_source_file_directive_resolver
+  ].map { |name| [name, "ceedling/test_invoker/#{name}"] }.concat( [
+    ['build_log_writer',                 'ceedling/build_log_writer'],
+    ['generator_test_results_backtrace', 'ceedling/generators/generator_test_results_backtrace']
+  ] ).each do |name, path|
     it "composes exactly what #{name}'s constructor takes" do
-      require "ceedling/test_invoker/#{name}"
+      require path
       klass = Object.const_get( name.split( '_' ).map( &:capitalize ).join )
 
       expect(OBJECTS_WIRING.dig( name, 'compose' )).to match_array( klass.constructor_keys.map( &:to_s ) )

data/spec/units/test_invoker_spec.rb

@@ -18,7 +18,9 @@ describe TestInvoker do
     @loginator              = double( "Loginator" )
     @verbosinator           = double( "Verbosinator" )
     @test_pipeline_manager  = double( "TestPipelineManager" )
+    @include_pathinator     = double( "IncludePathinator" )
 
+    allow(@include_pathinator).to receive(:forget_header_listings)
     allow(@plugin_manager).to receive(:pre_test_build)
     allow(@plugin_manager).to receive(:post_test_build)
     allow(@dependinator).to receive(:open)
@@ -32,7 +34,8 @@ describe TestInvoker do
         :dependinator           => @dependinator,
         :loginator              => @loginator,
         :verbosinator           => @verbosinator,
-        :test_pipeline_manager  => @test_pipeline_manager
+        :test_pipeline_manager  => @test_pipeline_manager,
+        :include_pathinator     => @include_pathinator
       }
     )
   end
@@ -67,6 +70,16 @@ describe TestInvoker do
       @invoker.setup_and_invoke( tests: [] )
     end
 
+    # A header a `pre_test_build` hook writes is listed, and a later test build in the same
+    # process lists each directory afresh
+    it "forgets remembered header listings after the pre-test-build hook and before the run" do
+      expect(@plugin_manager).to receive(:pre_test_build).ordered
+      expect(@include_pathinator).to receive(:forget_header_listings).ordered
+      expect(@test_pipeline_manager).to receive(:run).ordered
+
+      @invoker.setup_and_invoke( tests: [] )
+    end
+
     # Isolates each pipeline identifier's own cache file (see Dependinator#open) --
     # sharing one cache file between, say, an ordinary test run and a plugin's own
     # context (:gcov, :valgrind, ...) would let one's full-run pruning flush (see

data/spec/units/test_source_file_directive_resolver_spec.rb

@@ -124,7 +124,7 @@ describe TestSourceFileDirectiveResolver do
         .with( filepath: 'foo.c', complain: :ignore, context: TEST_SYM ).and_return( 'src/foo.c' )
 
       expect {
-        @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+        @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
       }.to_not raise_error
     end
 
@@ -135,7 +135,7 @@ describe TestSourceFileDirectiveResolver do
         .with( filepath: 'foo.c', complain: :ignore, context: TEST_SYM ).and_return( nil )
 
       expect {
-        @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+        @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
       }.to raise_error( CeedlingException, /'foo\.c'.*cannot be found in the source file collection/ )
     end
 
@@ -144,7 +144,7 @@ describe TestSourceFileDirectiveResolver do
         .with( 'test/TestFoo.c' ).and_return( ['-:foo.txt'] )
 
       expect {
-        @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+        @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
       }.to raise_error( CeedlingException, /'foo\.txt'.*not a .*\.c.*source file/ )
     end
 
@@ -155,10 +155,41 @@ describe TestSourceFileDirectiveResolver do
         .with( filepath: 'foo.c', complain: :ignore, context: TEST_SYM ).and_return( nil )
 
       expect {
-        @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+        @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
       }.to raise_error( CeedlingException, /^File 'foo\.c'/ )
     end
 
+    # The check and the build find an entry the same way, so an entry the build uses passes
+    it "anchors a .. entry to the test's own directory, as the build does" do
+      allow(@test_context_extractor).to receive(:lookup_build_directive_sources_list)
+        .with( 'test/unit/TestFoo.c' ).and_return( ['../common/extra.c'] )
+      expect(@file_finder).to receive(:find_build_input_file)
+        .with( filepath: 'test/common/extra.c', complain: :ignore, context: TEST_SYM ).and_return( 'test/common/extra.c' )
+
+      expect {
+        @resolver.validate!( test: 'TestFoo', test_filepath: 'test/unit/TestFoo.c', context: TEST_SYM )
+      }.to_not raise_error
+    end
+
+    it "looks entries up in the build's own context" do
+      allow(@test_context_extractor).to receive(:lookup_build_directive_sources_list)
+        .with( 'test/TestFoo.c' ).and_return( ['foo.c'] )
+      expect(@file_finder).to receive(:find_build_input_file)
+        .with( filepath: 'foo.c', complain: :ignore, context: :gcov ).and_return( 'src/foo.c' )
+
+      @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: :gcov )
+    end
+
+    it "names the test it was given in its error" do
+      allow(@test_context_extractor).to receive(:lookup_build_directive_sources_list)
+        .with( 'test/m13/test_m13.c' ).and_return( ['mod_13_typo.c'] )
+      allow(@file_finder).to receive(:find_build_input_file).and_return( nil )
+
+      expect {
+        @resolver.validate!( test: 'test/m13/test_m13', test_filepath: 'test/m13/test_m13.c', context: TEST_SYM )
+      }.to raise_error( CeedlingException, %r{'mod_13_typo\.c' specified with TEST_SOURCE_FILE\(\) in test/m13/test_m13 cannot be found} )
+    end
+
     context "when assembly support is enabled" do
       before(:each) do
         allow(@configurator).to receive(:test_build_use_assembly).and_return( true )
@@ -172,7 +203,7 @@ describe TestSourceFileDirectiveResolver do
           .with( filepath: 'foo.asm', complain: :ignore, context: TEST_SYM ).and_return( 'src/foo.asm' )
 
         expect {
-          @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+          @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
         }.to_not raise_error
       end
 
@@ -183,7 +214,7 @@ describe TestSourceFileDirectiveResolver do
           .with( filepath: 'foo.c', complain: :ignore, context: TEST_SYM ).and_return( 'src/foo.c' )
 
         expect {
-          @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+          @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
         }.to_not raise_error
       end
 
@@ -192,7 +223,7 @@ describe TestSourceFileDirectiveResolver do
           .with( 'test/TestFoo.c' ).and_return( ['foo.txt'] )
 
         expect {
-          @resolver.validate!( test: 'TestFoo', filepath: 'test/TestFoo.c' )
+          @resolver.validate!( test: 'TestFoo', test_filepath: 'test/TestFoo.c', context: TEST_SYM )
         }.to raise_error( CeedlingException, /not a \.c or \.asm source file/ )
       end
     end

data/spec/units/tool_executor_spec.rb

@@ -81,6 +81,15 @@ describe ToolExecutor do
 
       expect(command[:line]).to include('--flag=2')
     end
+
+    # GH #1373: a value was a replacement string, so its \0, \1 and \\ were read as back-references
+    it 'substitutes a value holding backslash sequences exactly as given' do
+      tool_config = { :name => 't', :executable => 'exe', :arguments => [ { '-I"$"' => ['C:\proj\2024\0x', 'a\\\\b'] } ] }
+
+      command = @tool_executor.build_command_line( tool_config, [] )
+
+      expect(command[:line]).to eq( 'exe -I"C:\proj\2024\0x" -I"a\\\\b"' )
+    end
   end
 
   # A command run with :boom false always reports an :exit_code of 0, so a caller handling
@@ -453,6 +462,23 @@ describe ToolExecutor do
       expect(command[:line]).to include('-o "out.o"')
     end
 
+    # GH #1373: a value was a replacement string, so its \0, \1 and \\ were read as back-references
+    it 'substitutes a value holding backslash sequences exactly as given' do
+      tool_config = { :name => 't', :executable => 'exe', :arguments => ['-c "${1}"', '${2}'] }
+
+      command = @tool_executor.build_command_line(tool_config, [], 'C:\proj\2024\0x', 'a\\\\b\&c')
+
+      expect(command[:line]).to eq( 'exe -c "C:\proj\2024\0x" a\\\\b\&c' )
+    end
+
+    it 'substitutes each value of an Array exactly as given' do
+      tool_config = { :name => 't', :executable => 'exe', :arguments => ['"${1}"'] }
+
+      command = @tool_executor.build_command_line(tool_config, [], ['C:\a\1', 'C:\b\0'])
+
+      expect(command[:line]).to eq( 'exe "C:\a\1" "C:\b\0"' )
+    end
+
     it 'raises CeedlingException when args is empty but a ${n} element is present' do
       tool_config = { :name => 'my_tool', :executable => 'exe', :arguments => ['${1}'] }