ceedling 1.2.1 → 1.2.2

data/spec/units/plugins/valgrind_spec.rb

@@ -42,7 +42,7 @@ describe Valgrind do
   let(:plugin_manager)      { double('plugin_manager', register_build_failure: nil) }
   let(:plugin_reportinator) { double('plugin_reportinator') }
   let(:dependinator)        { double('dependinator', register: nil) }
-  let(:file_wrapper)        { double('file_wrapper', exist?: true, read: '', mkdir: nil) }
+  let(:file_wrapper)        { double('file_wrapper', exist_with_retry?: true, read: '', mkdir: nil) }
   let(:system_wrapper)      { double('system_wrapper', windows?: false) }
   let(:ceedling) do
     {
@@ -207,13 +207,28 @@ describe Valgrind do
   end
 
   describe '#pre_test_fixture_register' do
-    def register(project_config, context: VALGRIND_SYM)
+    before(:each) do
+      allow(file_wrapper).to receive(:mkdir_for) { |path| path }
+    end
+
+    def register(project_config, context: VALGRIND_SYM, test_name: 'test_thing')
       valgrind = build_valgrind(project_config)
-      arg_hash = { context: context, test_name: 'test_thing', target: 'build/out/test_thing.out', tool: { name: 'original' } }
+      arg_hash = { context: context, test_name: test_name, target: 'build/out/test_thing.out', tool: { name: 'original' } }
       valgrind.pre_test_fixture_register(arg_hash)
       [valgrind, arg_hash]
     end
 
+    # GH #1364: Valgrind writes its reports but makes no directories of its own
+    it "makes the directories a nested test's reports go in" do
+      expect(file_wrapper).to receive(:mkdir_for).with('artifacts/valgrind/test/unit/test_thing.log')
+      expect(file_wrapper).to receive(:mkdir_for).with('artifacts/valgrind/test/unit/test_thing.xml')
+
+      _valgrind, arg_hash = register({ valgrind_xml_report: true }, test_name: 'test/unit/test_thing')
+
+      expect(arg_hash[:tool][:arguments]).to include('--log-file="artifacts/valgrind/test/unit/test_thing.log"')
+      expect(arg_hash[:tool][:arguments]).to include('--xml-file="artifacts/valgrind/test/unit/test_thing.xml"')
+    end
+
     it 'leaves a non-valgrind context untouched' do
       original = { name: 'original' }
       valgrind = build_valgrind({})
@@ -232,10 +247,10 @@ describe Valgrind do
       expect(arg_hash[:tool][:arguments]).to include('--log-file="artifacts/valgrind/test_thing.log"')
     end
 
-    it 'appends the executable substitution token last' do
+    it 'appends the executable substitution token last, quoted as a path' do
       _valgrind, arg_hash = register({ valgrind_arguments: ['--leak-check=full'] })
 
-      expect(arg_hash[:tool][:arguments].last).to eq('${1}')
+      expect(arg_hash[:tool][:arguments].last).to eq('"${1}"')
     end
 
     it 'places user arguments after the plugin-managed ones' do
@@ -315,7 +330,7 @@ describe Valgrind do
     end
 
     def explain(report, project_config: {}, context: VALGRIND_SYM, crash_notice: true, exists: true)
-      wrapper  = double('file_wrapper', exist?: exists, read: report)
+      wrapper  = double('file_wrapper', exist_with_retry?: exists, read: report)
       valgrind = build_valgrind(project_config, file_wrapper: wrapper)
       arg_hash = { context: context, test_name: 'test_thing', crash_notice: crash_notice, explanation: nil }
       valgrind.explain_test_crash( arg_hash )
@@ -384,7 +399,7 @@ describe Valgrind do
 
   describe '#post_test_fixture_execute' do
     def execute(project_config, log_contents, exists: true, result_file: File.join('build', 'valgrind', 'results', 'test_thing.pass'))
-      wrapper  = double('file_wrapper', exist?: exists, read: log_contents)
+      wrapper  = double('file_wrapper', exist_with_retry?: exists, read: log_contents)
       valgrind = build_valgrind(project_config, file_wrapper: wrapper)
       valgrind.post_test_fixture_execute(
         { context: VALGRIND_SYM, test_name: 'test_thing', result_file: result_file }
@@ -451,7 +466,7 @@ describe Valgrind do
 
     # A silent skip reads exactly like a clean result. It is not one.
     it 'warns and records nothing when no report was written' do
-      expect(loginator).to receive(:log).with(/wrote no report for test_thing/, anything, anything)
+      expect(loginator).to receive(:log).with(/wrote no report for test_thing/, Verbosity::COMPLAIN)
 
       valgrind = execute({}, '', exists: false)
 

data/spec/units/preprocess/preprocessinator_comment_stripper_spec.rb

@@ -9,7 +9,7 @@ require 'spec_helper'
 require 'ceedling/preprocess/c_comment_scanner'
 require 'ceedling/preprocess/preprocessinator_comment_stripper'
 require 'ceedling/preprocess/preprocessinator_code_finder'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 
 RSpec.describe PreprocessinatorCommentStripper do
 

data/spec/units/rake_app/rakefile_component_resolver_spec.rb

@@ -33,6 +33,18 @@ describe RakefileComponentResolver do
 
       expect(result).to eq(['ceedling/plugins'])
     end
+
+    # The path handling audit around GH #1370: bin/ reads :load_paths before the
+    # configuration pipeline, so it must expand and standardize them as that pipeline does
+    it 'expands and standardizes each configured load path, leaving the configuration as written' do
+      config = { plugins: { load_paths: ["\#{'my'}\\plugins\\", '~/plugins'] } }
+      expand = ->(path) { path.sub( "\#{'my'}", 'my' ) }
+
+      result = described_class.prepare_plugin_load_paths(config, 'ceedling/plugins', expand: expand)
+
+      expect(result).to eq(['my/plugins', File.join( Dir.home, 'plugins' ), 'ceedling/plugins'])
+      expect(config[:plugins][:load_paths].first).to eq( "\#{'my'}\\plugins\\" )
+    end
   end
 
   describe '.gather_rakefiles' do
@@ -125,6 +137,15 @@ describe RakefileComponentResolver do
         File.join('ceedling/plugins', 'gcov', 'gcov.rake'),
       ])
     end
+
+    it 'finds a plugin below a load path that needs expanding' do
+      config = { project: { release_build: false }, plugins: { enabled: ['mine'], load_paths: ["\#{'my'}/plugins"] } }
+      allow(File).to receive(:exist?).with(File.join('my/plugins', 'mine', 'mine.rake')).and_return(true)
+
+      result = described_class.resolve(config, 'lib', 'ceedling/plugins', expand: ->(path) { path.sub( "\#{'my'}", 'my' ) })
+
+      expect(result.last).to eq( File.join('my/plugins', 'mine', 'mine.rake') )
+    end
   end
 
   describe '.plugin_rake_files' do

data/spec/units/release_build_executor_spec.rb

@@ -23,6 +23,7 @@ describe ReleaseBuildExecutor do
     @file_wrapper     = double( "FileWrapper" )
     @file_path_utils  = double( "FilePathUtils" )
     @dependinator     = double( "Dependinator" )
+    @library_resolver = double( "LibraryResolver" )
 
     @tools_release_compiler  = { name: 'fake compiler' }
     @tools_release_assembler = { name: 'fake assembler' }
@@ -56,6 +57,8 @@ describe ReleaseBuildExecutor do
     allow(@dependinator).to receive(:register_gcc_deps_file)
     allow(@dependinator).to receive(:stale?).and_return( true )
     allow(@dependinator).to receive(:mark_fresh)
+    allow(@library_resolver).to receive(:link_files).and_return( [] )
+    allow(@library_resolver).to receive(:search_path_arguments).and_return( [] )
 
     @executor = described_class.new(
       {
@@ -67,7 +70,8 @@ describe ReleaseBuildExecutor do
         :file_finder      => @file_finder,
         :file_wrapper     => @file_wrapper,
         :file_path_utils  => @file_path_utils,
-        :dependinator     => @dependinator
+        :dependinator     => @dependinator,
+        :library_resolver => @library_resolver
       }
     )
 
@@ -278,6 +282,18 @@ describe ReleaseBuildExecutor do
       @executor.link( @state )
     end
 
+    it "separates every configured library extension, and a subproject's, from plain objects" do
+      stub_const( "EXTENSION_LIBRARIES", FilenameExtension.new( ['.a', '.so'] ) )
+      stub_const( "EXTENSION_SUBPROJECTS", '.lib' )
+      @state.objects = ['build/release/out/foo.o', 'vendor/libbar.a', 'vendor/libbaz.so', 'sub/x.lib', 'build/release/out/so.o']
+
+      expect(@generator).to receive(:generate_executable_file) do |_tool, _sym, objects, *_rest|
+        expect(objects).to eq( ['build/release/out/foo.o', 'build/release/out/so.o'] )
+      end
+
+      @executor.link( @state )
+    end
+
     it "formats a separated library as a linker argument via the configured flag template" do
       stub_const( "EXTENSION_LIBRARIES", FilenameExtension.new('.a') )
       stub_const( "LIBRARIES_FLAG", '-l${1}' )
@@ -302,9 +318,8 @@ describe ReleaseBuildExecutor do
       @executor.link( @state )
     end
 
-    it "formats configured library search paths as linker arguments via the configured flag template" do
-      stub_const( "PATHS_LIBRARIES", ['vendor/lib'] )
-      stub_const( "LIBRARIES_PATH_FLAG", '-L${1}' )
+    it "links with the library search path arguments the resolver gives" do
+      allow(@library_resolver).to receive(:search_path_arguments).and_return( ['-Lvendor/lib'] )
 
       expect(@generator).to receive(:generate_executable_file) do |_tool, _sym, _objects, _flags, _target, _map, _lib_args, lib_paths|
         expect(lib_paths).to eq( ['-Lvendor/lib'] )
@@ -313,14 +328,12 @@ describe ReleaseBuildExecutor do
       @executor.link( @state )
     end
 
-    # Quoted like every other default path argument, so a path with a space survives the shell
-    it "quotes each library search path under the default flag template" do
-      stub_const( "PATHS_LIBRARIES", ['vendor/third party/lib'] )
-      stub_const( "LIBRARIES_PATH_FLAG", DEFAULT_CEEDLING_PROJECT_CONFIG[:libraries][:path_flag] )
+    # A target named by an absolute :output may sit in a directory no build made
+    it "makes the target's directory before linking" do
+      allow(@configurator).to receive(:project_release_build_target).and_return( '/elsewhere/out/app.elf' )
 
-      expect(@generator).to receive(:generate_executable_file) do |_tool, _sym, _objects, _flags, _target, _map, _lib_args, lib_paths|
-        expect(lib_paths).to eq( ['-L "vendor/third party/lib"'] )
-      end
+      expect(@file_wrapper).to receive(:mkdir).with( '/elsewhere/out' ).ordered
+      expect(@generator).to receive(:generate_executable_file).ordered
 
       @executor.link( @state )
     end
@@ -338,14 +351,40 @@ describe ReleaseBuildExecutor do
     it "registers the resolved link flags and library arguments, not just the object files, as meta" do
       stub_const( "LIBRARIES_SYSTEM", ['m'] )
       stub_const( "LIBRARIES_FLAG", '-l${1}' )
-      stub_const( "PATHS_LIBRARIES", ['vendor/lib'] )
-      stub_const( "LIBRARIES_PATH_FLAG", '-L${1}' )
+      allow(@library_resolver).to receive(:search_path_arguments).and_return( ['-Lvendor/lib'] )
       @state.link_flags = ['-Wall']
 
       expect(@dependinator).to receive(:register).with(
         'build/release/out/project.out',
         files: ['build/release/out/foo.o'],
-        meta:  { flags: ['-Wall'], lib_args: ['-lm'], lib_paths: ['-Lvendor/lib'], tools: [@tools_release_linker] }
+        meta:  { flags: ['-Wall'], lib_args: ['-lm'], lib_paths: ['-Lvendor/lib'], tools: [@tools_release_linker], objects: ['build/release/out/foo.o'], libraries: [] }
+      )
+
+      @executor.link( @state )
+    end
+
+    # A source dropped from the build leaves every remaining object as it was, so only the
+    # object list, as meta, relinks an artifact that would otherwise keep the dropped code
+    it "registers the objects it links as meta" do
+      expect(@dependinator).to receive(:register).with(
+        'build/release/out/project.out', files: ['build/release/out/foo.o'], meta: hash_including( objects: ['build/release/out/foo.o'] )
+      )
+
+      @executor.link( @state )
+    end
+
+    # GH #1368: a library rebuilt under the same name changed nothing a link registered
+    it "registers the library files its libraries resolve to, including those named by path, as files and as meta" do
+      @state.objects = ['build/release/out/foo.o', 'vendor/prebuilt/libp.a']
+      stub_const( 'EXTENSION_LIBRARIES', FilenameExtension.new( ['.a'] ) )
+      stub_const( 'LIBRARIES_SYSTEM', ['m'] )
+      stub_const( 'LIBRARIES_RELEASE', ['x'] )
+
+      expect(@library_resolver).to receive(:link_files).with( ['vendor/prebuilt/libp.a', 'm', 'x'] ).and_return( ['vendor/prebuilt/libp.a', 'vendor/lib/libx.a', 'build/deps/libfusion.a'] )
+      expect(@dependinator).to receive(:register).with(
+        'build/release/out/project.out',
+        files: ['build/release/out/foo.o', 'vendor/prebuilt/libp.a', 'vendor/lib/libx.a', 'build/deps/libfusion.a'],
+        meta:  hash_including( libraries: ['vendor/prebuilt/libp.a', 'vendor/lib/libx.a', 'build/deps/libfusion.a'] )
       )
 
       @executor.link( @state )

data/spec/units/release_build_planner_spec.rb

@@ -51,9 +51,21 @@ describe ReleaseBuildPlanner do
     end
 
     it "includes extra link-only objects alongside the compiled sources" do
-      allow(@configurator).to receive(:collection_release_artifact_extra_link_objects).and_return( ['vendor/cexception/CException.o'] )
-      expect(@file_path_utils).to receive(:form_release_build_objects_filelist).with( ['src/Foo.c', 'vendor/cexception/CException.o'] ).and_return( [] )
+      allow(@configurator).to receive(:collection_release_artifact_extra_link_objects).and_return( ['CException.o'] )
       @planner.plan( @state, files: nil )
+      expect( @state.objects ).to eq( ['build/release/out/Foo.o', 'build/release/out/CException.o'] )
+    end
+
+    # A link-only name is no source of its own, so naming the object a compiled source builds
+    # to is no collision between two sources
+    it "places link-only objects apart from the compiled sources, adding a shared object once" do
+      allow(@configurator).to receive(:collection_release_build_input).and_return( ['build/vendor/c_exception/lib/CException.c'] )
+      allow(@configurator).to receive(:collection_release_artifact_extra_link_objects).and_return( ['CException.o'] )
+      expect(@file_path_utils).to receive(:form_release_build_objects_filelist).with( ['build/vendor/c_exception/lib/CException.c'] ).and_return( ['build/release/out/CException.o'] )
+      expect(@file_path_utils).to receive(:form_release_build_objects_filelist).with( ['CException.o'] ).and_return( ['build/release/out/CException.o'] )
+
+      @planner.plan( @state, files: nil )
+      expect( @state.objects ).to eq( ['build/release/out/CException.o'] )
     end
 
     it "scopes the object list to just the given file when files is provided, ignoring the full source collection" do
@@ -124,7 +136,7 @@ describe ReleaseBuildPlanner do
 
         expect( compiler[:arguments] ).to include( '-fPIC' )
         expect( linker[:executable] ).to eq( 'ar' )
-        expect( linker[:arguments] ).to eq( ['rcs', '${2}', '${1}'] )
+        expect( linker[:arguments] ).to eq( ['rcs', '"${2}"', '"${1}"'] )
       end
 
       it "does nothing when the project has configured its own compiler tool (not the Ceedling default)" do

data/spec/units/reportinator_spec.rb

@@ -225,14 +225,14 @@ describe Reportinator do
       expect(result).to eq("Compiling bar::baz.c...")
     end
 
-    it 'omits module label when filename matches only the last segment of a mirrored, multi-segment module name' do
-      result = @rp.generate_module_progress(module_name: 'adc/TestFoo', filename: 'TestFoo.c', operation: 'Compiling')
+    it 'omits module label when filename matches only the last segment of a multi-segment module name' do
+      result = @rp.generate_module_progress(module_name: 'test/adc/TestFoo', filename: 'TestFoo.c', operation: 'Compiling')
       expect(result).to eq("Compiling TestFoo.c...")
     end
 
-    it 'prepends the full mirrored module name when filename differs from its last segment' do
-      result = @rp.generate_module_progress(module_name: 'adc/TestFoo', filename: 'MockBar.c', operation: 'Generating mock for')
-      expect(result).to eq("Generating mock for adc/TestFoo::MockBar.c...")
+    it 'prepends the full module name when filename differs from its last segment' do
+      result = @rp.generate_module_progress(module_name: 'test/adc/TestFoo', filename: 'MockBar.c', operation: 'Generating mock for')
+      expect(result).to eq("Generating mock for test/adc/TestFoo::MockBar.c...")
     end
   end
 

data/spec/units/standin_headerinator_spec.rb

@@ -10,6 +10,7 @@ require 'ceedling/constants'
 require 'ceedling/includes/includes'
 require 'ceedling/test_invoker/test_invoker_types'
 require 'ceedling/test_invoker/standin_headerinator'
+require 'ceedling/test_invoker/mock_locator'
 
 describe StandinHeaderinator do
   before(:each) do
@@ -33,6 +34,11 @@ describe StandinHeaderinator do
     end
     allow(@mock_locator).to receive(:header_collection).and_return( ['src/drivers/foo.h'] )
     allow(@mock_locator).to receive(:locate).and_return( ['src/drivers/foo.h', 'drivers'] )
+    allow(@mock_locator).to receive(:placement) do |mocks_root:, subdir:, **|
+      dir = subdir.empty? ? mocks_root : File.join( mocks_root, subdir )
+      MockLocator::MockPlacement.new( folder: nil, directory: dir, root: dir, reach: dir )
+    end
+    allow(@mock_locator).to receive(:search_directories) { |placement| [placement.directory] }
 
     @standins = described_class.new(
       configurator: @configurator, loginator: @loginator, reportinator: @reportinator,
@@ -110,9 +116,33 @@ describe StandinHeaderinator do
       expect(dirs).to eq( ['build/test/mocks/a_test/drivers'] )
     end
 
-    it "gives no directories when the test has no mock root" do
+    # The test's #include reaches the stand-in only from the directory the folder climbs from, so it must exist
+    it "writes a climbing folder's stand-in where its mock will be, giving and making the directory it is reached from" do
+      climbing = MockLocator::MockPlacement.new( folder: '../x', directory: 'build/test/mocks/a_test/_up_/x', root: 'build/test/mocks/a_test/_up_/_up_', reach: 'build/test/mocks/a_test/_up_/_up_' )
+      allow(@mock_locator).to receive(:placement).with( mocks_root: 'build/test/mocks/a_test', subdir: 'drivers', include_path: '../x/MockFoo.h' ).and_return( climbing )
+      allow(@mock_locator).to receive(:search_directories).with( climbing ).and_return( [climbing.directory, climbing.root] )
+
+      expect(@file_wrapper).to receive(:mkdir).with( 'build/test/mocks/a_test/_up_/_up_' )
+      expect(@file_wrapper).to receive(:write).with( 'build/test/mocks/a_test/_up_/x/MockFoo.h', anything )
+
+      expect(@standins.place( @testable, [Include.new( '../x/MockFoo.h' )] ))
+        .to eq( ['build/test/mocks/a_test/_up_/x', 'build/test/mocks/a_test/_up_/_up_'] )
+    end
+
+    # The real mock opens with the header as CMock names it, by the folder CMock is given
+    it "includes the header by the folder its mock is named by" do
+      named = MockLocator::MockPlacement.new( folder: 'drivers', directory: 'build/test/mocks/a_test/drivers', root: 'build/test/mocks/a_test', reach: 'build/test/mocks/a_test' )
+      allow(@mock_locator).to receive(:placement).and_return( named )
+
+      expect(@file_wrapper).to receive(:write).with( 'build/test/mocks/a_test/drivers/MockFoo.h', "#{StandinHeaderinator::MARKER}\n#include \"drivers/foo.h\"\n" )
+
+      @standins.place( @testable, [Include.new( 'drivers/MockFoo.h' )] )
+    end
+
+    it "places no stand-in and gives no directories when the test has no mock root" do
       @testable.paths = {}
 
+      expect(@file_wrapper).to_not receive(:write)
       expect(@standins.place( @testable, [Include.new( 'MockFoo.h' )] )).to eq( [] )
     end
 

data/spec/units/test_build_executor_spec.rb

@@ -9,6 +9,7 @@ require 'spec_helper'
 require 'ceedling/filename_extension'
 require 'rake'
 require 'ceedling/test_invoker/test_build_executor'
+require 'ceedling/test_invoker/mock_locator'
 require 'ceedling/test_invoker/test_invoker_types'
 require 'ceedling/partials/partials'
 require 'ceedling/test_context_extractor'
@@ -35,6 +36,7 @@ describe TestBuildExecutor do
     @gcc_dependency_parser                                        = double( "GccDependencyParser" )
     @quote_include_isolator                                       = double( "QuoteIncludeIsolator" )
     @generator_helper                                                = double( "GeneratorHelper" )
+    @library_resolver                                                = double( "LibraryResolver" )
 
     @tools_test_compiler                     = { name: 'fake compiler' }
     @tools_test_assembler                    = { name: 'fake assembler' }
@@ -107,6 +109,8 @@ describe TestBuildExecutor do
     allow(@dependinator).to receive(:stale?).and_return( true )
     allow(@dependinator).to receive(:mark_fresh)
     allow(@test_source_file_directive_resolver).to receive(:validate!)
+    allow(@library_resolver).to receive(:link_files).and_return( [] )
+    allow(@library_resolver).to receive(:search_path_arguments).and_return( [] )
 
     @executor = described_class.new(
       {
@@ -123,7 +127,11 @@ describe TestBuildExecutor do
         :dependinator            => @dependinator,
         :gcc_dependency_parser   => @gcc_dependency_parser,
         :quote_include_isolator  => @quote_include_isolator,
-        :generator_helper        => @generator_helper
+        :generator_helper        => @generator_helper,
+        :library_resolver        => @library_resolver,
+        :mock_locator            => MockLocator.new(
+          configurator: @configurator, include_pathinator: double( 'include_pathinator' ), file_finder: @file_finder, file_path_utils: @file_path_utils
+        )
       }
     )
 
@@ -1059,12 +1067,42 @@ describe TestBuildExecutor do
       expect(@dependinator).to receive(:register).with(
         'build/a_test.out',
         files: ['build/foo.o'],
-        meta:  { flags: [], lib_args: [], lib_paths: [], tools: [@tools_test_linker] }
+        meta:  { flags: [], lib_args: [], lib_paths: [], tools: [@tools_test_linker], objects: ['build/foo.o'], libraries: [] }
       )
 
       @executor.stage_build_executables( @state )
     end
 
+    # GH #1368: a library rebuilt under the same name changed nothing a link registered
+    it "registers the library files its libraries resolve to, as files and as meta" do
+      allow(@dependinator).to receive(:stale?).and_return( false )
+      allow(@configurator).to receive(:project_config_hash).and_return( { libraries_test: ['x'] } )
+      stub_const( 'LIBRARIES_SYSTEM', ['m', 'fusion'] )
+
+      expect(@library_resolver).to receive(:link_files).with( ['x', 'm', 'fusion'] ).and_return( ['vendor/lib/libx.a', 'build/deps/libfusion.so.1'] )
+      expect(@dependinator).to receive(:register).with(
+        'build/a_test.out',
+        files: ['build/foo.o', 'vendor/lib/libx.a', 'build/deps/libfusion.so.1'],
+        meta:  hash_including( libraries: ['vendor/lib/libx.a', 'build/deps/libfusion.so.1'] )
+      )
+
+      @executor.stage_build_executables( @state )
+    end
+
+    # Staleness checks only the objects registered this build, so an object dropped from the
+    # link changes nothing they see. The list itself, as meta, does change (a source deleted,
+    # excluded, or moved out of the configured paths).
+    it "registers the objects it links as meta, as a plain list" do
+      allow(@dependinator).to receive(:stale?).and_return( false )
+      @testable.objects = FileList.new.tap { |list| list << 'build/foo.o' }
+
+      expect(@dependinator).to receive(:register).with( 'build/a_test.out', files: ['build/foo.o'], meta: hash_including( objects: ['build/foo.o'] ) ) do |_, files:, meta:|
+        expect(meta[:objects]).to be_an_instance_of( Array )
+      end
+
+      @executor.stage_build_executables( @state )
+    end
+
     it "logs a summary line stating how many executables were recalled from cache" do
       allow(@dependinator).to receive(:stale?).and_return( false )
 
@@ -1658,7 +1696,7 @@ describe TestBuildExecutor do
         include_as( 'sub/MockFoo.h' )
 
         expect(@generator).to receive(:generate_mock)
-          .with( hash_including( output_path: 'build/test/mocks/sub', folder: 'sub' ) )
+          .with( hash_including( output_path: 'build/test/mocks/sub', mock_root: 'build/test/mocks', folder: 'sub' ) )
 
         @executor.stage_generate_mocks( @state )
       end
@@ -1685,6 +1723,30 @@ describe TestBuildExecutor do
         @executor.stage_generate_mocks( @state )
       end
 
+      # The path handling audit around GH #1370: a folder that climbs must not carry the
+      # mock out of its test's mocks directory
+      it "G14: keeps the mock below its test's mocks directory for a folder that climbs" do
+        include_as( '../x/MockFoo.h' )
+
+        expect(@generator).to receive(:generate_mock) do |args|
+          expect(args[:output_path].split( '/' )).to_not include( '..' )
+        end
+
+        @executor.stage_generate_mocks( @state )
+      end
+
+      # The compiler finds the mock as written only through CMock's root, so it must exist
+      it "roots CMock as deep as a climbing folder climbs, and makes that root" do
+        include_as( '../x/MockFoo.h' )
+
+        expect(@file_wrapper).to receive(:mkdir).with( 'build/test/mocks/_up_/x' )
+        expect(@file_wrapper).to receive(:mkdir).with( 'build/test/mocks/_up_/_up_' )
+        expect(@generator).to receive(:generate_mock)
+          .with( hash_including( output_path: 'build/test/mocks/_up_/x', mock_root: 'build/test/mocks/_up_/_up_', folder: '../x' ) )
+
+        @executor.stage_generate_mocks( @state )
+      end
+
       it "passes no folder when :mock_name_include_folder is disabled" do
         allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( false )
         include_as( 'sub/MockFoo.h' )

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