ceedling 1.2.0 → 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/rake_app/test_task_name_spec.rb

@@ -0,0 +1,47 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/rake_app/test_task_name'
+
+# Every per-file test task (test:, gen:mocks:, gcov:, valgrind:, sanitize:, bullseye:) turns
+# its task name into the test name file lookup needs. A directory ahead of the name
+# distinguishes same-named tests, so only the basename is prefixed (GH #1362).
+describe TestTaskName do
+  def name(task, root: 'gcov:')
+    TestTaskName.test_name( task, root: root, extensions: ['.c', '.cpp'], prefix: 'test_' )
+  end
+
+  it 'prefixes a bare name' do
+    expect( name( 'gcov:calculator.c' ) ).to eq( 'test_calculator' )
+  end
+
+  it 'leaves a name that already has the prefix' do
+    expect( name( 'gcov:test_calculator.c' ) ).to eq( 'test_calculator' )
+  end
+
+  it 'keeps a directory, prefixing only the file name' do
+    expect( name( 'gcov:test/calculator.c' ) ).to eq( 'test/test_calculator' )
+    expect( name( 'gcov:test/test_calculator.c' ) ).to eq( 'test/test_calculator' )
+    expect( name( 'gcov:test/unit/test_calculator.c' ) ).to eq( 'test/unit/test_calculator' )
+  end
+
+  it 'normalizes backslashes in a directory' do
+    expect( name( 'gcov:test\\unit\\calculator.c' ) ).to eq( 'test/unit/test_calculator' )
+  end
+
+  it 'strips any configured source extension, and leaves a name without one' do
+    expect( name( 'gcov:calculator.cpp' ) ).to eq( 'test_calculator' )
+    expect( name( 'gcov:calculator' ) ).to eq( 'test_calculator' )
+  end
+
+  it 'strips the given task root, whatever the task' do
+    expect( name( 'valgrind:test/calculator.c', root: 'valgrind:' ) ).to eq( 'test/test_calculator' )
+    expect( name( 'gen:mocks:test/calculator.c', root: 'gen:mocks:' ) ).to eq( 'test/test_calculator' )
+    expect( name( '  test:calculator.c  ', root: 'test:' ) ).to eq( 'test_calculator' )
+  end
+end

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' }
@@ -60,6 +62,8 @@ describe TestBuildExecutor do
     # real Configurator would raise NoMethodError.
     allow(@configurator).to receive(:tools_test_fixture_simple_backtrace).and_return( @tools_test_fixture_simple_backtrace )
     allow(@configurator).to receive(:project_config_hash).and_return( { project_use_backtrace: :simple } )
+    allow(@configurator).to receive(:include_test_case).and_return( '' )
+    allow(@configurator).to receive(:exclude_test_case).and_return( '' )
     allow(@configurator).to receive(:test_build_preprocess_force_fallback).and_return( false )
     allow(@configurator).to receive(:project_use_mocks).and_return( false )
     allow(@configurator).to receive(:project_use_exceptions).and_return( false )
@@ -105,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(
       {
@@ -121,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
+        )
       }
     )
 
@@ -1057,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 )
 
@@ -1339,7 +1379,9 @@ describe TestBuildExecutor do
         meta:  {
           tools: [@tools_test_fixture],
           use_backtrace: :gdb,
-          backtrace_tools: [@tools_test_fixture_simple_backtrace, @tools_test_backtrace_gdb]
+          backtrace_tools: [@tools_test_fixture_simple_backtrace, @tools_test_backtrace_gdb],
+          include_test_case: '',
+          exclude_test_case: ''
         }
       )
 
@@ -1363,13 +1405,32 @@ describe TestBuildExecutor do
         meta:  {
           tools: [@tools_test_fixture],
           use_backtrace: :simple,
-          backtrace_tools: [@tools_test_fixture_simple_backtrace]
+          backtrace_tools: [@tools_test_fixture_simple_backtrace],
+          include_test_case: '',
+          exclude_test_case: ''
         }
       )
 
       @executor.stage_execute( @state )
     end
 
+    # An executable linked with command line arguments enabled is the same with or without
+    # a filter, so only the filter tells one run's results from another's (GH #1360)
+    it "registers the command line test case filters as meta" do
+      @testable.executable_rebuilt = false
+      allow(@generator).to receive(:generate_test_results)
+      allow(@configurator).to receive(:include_test_case).and_return( 'test_one' )
+      allow(@configurator).to receive(:exclude_test_case).and_return( 'test_two' )
+
+      expect(@dependinator).to receive(:register).with(
+        @fixture_target,
+        files: ['build/a_test.out'],
+        meta:  hash_including( include_test_case: 'test_one', exclude_test_case: 'test_two' )
+      )
+
+      @executor.stage_execute( @state )
+    end
+
     it "reruns the test fixture when only the :tools ↳ :test_fixture configuration changed, even though the executable is unchanged" do
       @testable.executable_rebuilt = false
       allow(@dependinator).to receive(:stale?).with(@fixture_target).and_return( true )
@@ -1635,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
@@ -1662,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' )
@@ -1756,4 +1841,21 @@ describe TestBuildExecutor do
     end
   end
 
+
+  context "#fixture_meta" do
+    def meta(include: '', exclude: '')
+      allow(@configurator).to receive(:include_test_case).and_return( include )
+      allow(@configurator).to receive(:exclude_test_case).and_return( exclude )
+      @executor.fixture_meta( fixture_tool: @tools_test_fixture, use_backtrace: :simple, backtrace_tools: [] )
+    end
+
+    it "differs when the test case filters differ" do
+      expect( meta( include: 'test_one' ) ).not_to eq( meta( include: 'test_two' ) )
+      expect( meta( exclude: 'test_one' ) ).not_to eq( meta )
+    end
+
+    it "is the same for an unset filter, whether nil or empty" do
+      expect( meta( include: nil, exclude: nil ) ).to eq( meta( include: '', exclude: '' ) )
+    end
+  end
 end