ceedling 1.2.1 → 1.2.2

data/lib/ceedling/test_invoker/test_build_executor.rb

@@ -29,7 +29,9 @@ class TestBuildExecutor
     :dependinator,
     :gcc_dependency_parser,
     :quote_include_isolator,
-    :generator_helper
+    :generator_helper,
+    :library_resolver,
+    :mock_locator
   )
 
   # Stage 9: Preprocess header files to be mocked.
@@ -148,9 +150,10 @@ class TestBuildExecutor
       details  = mock.details
       testable = mock.testable
 
-      output_path = @file_path_utils.form_mock_output_path( testable.paths[:mocks], details.path )
-      folder, output_path = mock_folder_and_path( testable.paths[:mocks], output_path, details.include_path )
-      @file_wrapper.mkdir( output_path )
+      placement   = @mock_locator.placement( mocks_root: testable.paths[:mocks], subdir: details.path, include_path: details.include_path )
+      output_path = placement.directory
+      # The compiler reaches a climbing folder's mock only through CMock's root
+      @mock_locator.search_directories( placement ).each { |dir| @file_wrapper.mkdir( dir ) }
 
       # `details.input` -- not the stage 9 preprocessed target -- is the
       # correct antecedent here: it's exactly what CMock reads, whether or not
@@ -191,7 +194,8 @@ class TestBuildExecutor
         test:           testable.name,
         input_filepath: details.input,
         output_path:    output_path,
-        folder:         folder,
+        mock_root:      placement.root,
+        folder:         placement.folder,
         overrides:      overrides
       }
 
@@ -278,7 +282,8 @@ class TestBuildExecutor
   # Stage 16: Link test executables.
   def stage_build_executables(state)
     lib_args  = convert_libraries_to_arguments()
-    lib_paths = get_library_paths_to_arguments()
+    lib_paths = @library_resolver.search_path_arguments()
+    libraries = @library_resolver.link_files( test_library_entries() )
     skipped = 0
 
     @batchinator.exec(workload: :compile, things: state.testables) do |_, testable|
@@ -287,10 +292,14 @@ class TestBuildExecutor
       link_flags = testable.link_flags
       tool, link_flags = resolve_link_tool( context: state.context, tool: @configurator.tools_test_linker, flags: link_flags, executable: testable.executable )
 
+      # Staleness checks only the files registered here, so an object or library dropped from
+      # the link (a source deleted, excluded, or moved out of the configured paths) changes
+      # nothing they see. The object and library lists as meta do change.
+      objects = testable.objects.to_a
       @dependinator.register(
         testable.executable,
-        files: testable.objects,
-        meta:  { flags: link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [tool] }
+        files: objects + libraries,
+        meta:  { flags: link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [tool], objects: objects, libraries: libraries }
       )
       stale = @dependinator.stale?( testable.executable )
 
@@ -380,11 +389,9 @@ class TestBuildExecutor
 
     @batchinator.exec(workload: :test, things: state.testables) do |_, testable|
       begin
-        # `paths[:results]` is only per-test-unique for a test mirrored into its own
-        # subdirectory -- a test with no mirrored subdir shares that directory with
-        # every other such test, so the marker's own filename (not just its directory)
-        # must be test-specific too, matching clean_test_results' own `test + '.*'`
-        # naming below.
+        # `paths[:results]` is the directory of the test's name, which every test beside
+        # it shares, so the marker's own filename must be test-specific too, matching
+        # clean_test_results' own `test + '.*'` naming below.
         fixture_target = File.join( testable.paths[:results], "#{File.basename( testable.name )}.fixture_run" )
 
         fixture_tool = resolve_fixture_tool( context: state.context, tool: @configurator.tools_test_fixture, test_name: testable.name, target: fixture_target )
@@ -546,41 +553,18 @@ class TestBuildExecutor
   end
 
   def convert_libraries_to_arguments()
-    args = ((@configurator.project_config_hash[:libraries_test] || []) + ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])).flatten
+    args = test_library_entries()
     if (defined? LIBRARIES_FLAG)
       args.map! { |v| LIBRARIES_FLAG.gsub( /\$\{1\}/, v ) }
     end
     return args
   end
 
-  def get_library_paths_to_arguments()
-    paths = (defined? PATHS_LIBRARIES) ? (PATHS_LIBRARIES || []).clone : []
-    if (defined? LIBRARIES_PATH_FLAG)
-      paths.map! { |v| LIBRARIES_PATH_FLAG.gsub( /\$\{1\}/, v ) }
-    end
-    return paths
-  end
-
   private
 
-  # Finds the folder a mock's #include names and the directory the mock is written to.
-  #
-  # CMock names a mock's guard and lifecycle functions by that folder, and the runner names
-  # its calls by the same #include. Two same-named mocks stay distinct only if the folder
-  # reaches CMock. CMock writes below its own root at that folder, so the folder must end the
-  # mock's directory. A folder trailing the mirrored location keeps that location. An #include
-  # spelling more path than the mirror holds moves its mock below the per-test root at the
-  # written path, which the root search path still reaches. A bare #include has no folder.
-  # Without :mock_name_include_folder no folder is passed, and CMock names by filename alone.
-  def mock_folder_and_path(mocks_root, output_path, include_path)
-    return [nil, output_path] unless @configurator.cmock_mock_name_include_folder
-
-    folder = File.dirname( include_path.to_s ).sub( %r{\A(?:\./)+}, '' )
-
-    return [nil, output_path] if folder.empty? || folder == '.'
-    return [folder, output_path] if output_path.end_with?( File.join( '', folder ) )
-
-    return [folder, File.join( mocks_root, folder )]
+  # The :libraries entries a test links, whatever form each takes
+  def test_library_entries()
+    return ((@configurator.project_config_hash[:libraries_test] || []) + ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])).flatten
   end
 
   # Compile a single C or assembly source file into an object file. Returns

data/lib/ceedling/test_invoker/test_build_planner.rb

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

data/lib/ceedling/test_invoker/test_build_setup.rb

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

data/lib/ceedling/test_invoker/test_build_validations.rb

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

data/lib/ceedling/test_invoker/test_file_preprocessinator.rb

@@ -50,7 +50,7 @@ class TestFilePreprocessinator
       state.lock.synchronize { skipped += 1 } unless stale
 
       stale ? scan_source_directives( testable ) : recall_source_directives( testable )
-      state.testables.each_value { |each| @test_source_file_directive_resolver.validate!( test: testable.name, filepath: each.filepath ) }
+      @test_source_file_directive_resolver.validate!( test: testable.name, test_filepath: testable.filepath, context: state.context )
     end
 
     log_skip_summary( task: "test file preprocessing", count: skipped, noun: "test files" )

data/lib/ceedling/test_invoker/test_invoker.rb

@@ -22,7 +22,8 @@ class TestInvoker
     :dependinator,
     :loginator,
     :verbosinator,
-    :test_pipeline_manager
+    :test_pipeline_manager,
+    :include_pathinator
   )
 
   def setup
@@ -40,6 +41,10 @@ class TestInvoker
     timestamp_s = SystemWrapper.time_stopwatch_s()
     @plugin_manager.pre_test_build( context, timestamp_s )
 
+    # After the hook, so a header it writes is listed, and once per run, so a later run in
+    # the same process lists every search path afresh
+    @include_pathinator.forget_header_listings
+
     # `identifier: context` isolates this run's own cache file (see Dependinator#open) --
     # a plugin building its own variant of the test pipeline under a distinct context
     # (:gcov, :valgrind, ...) gets its own cache automatically, never sharing one with

data/lib/ceedling/test_invoker/test_pipeline_helpers.rb

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

data/lib/ceedling/test_invoker/test_source_file_directive_resolver.rb

@@ -7,9 +7,8 @@
 
 require 'ceedling/constants'
 require 'ceedling/exceptions'
-require 'ceedling/file_path_utils'
-require 'ceedling/path_matcher'
-require 'ceedling/test_invoker/test_build_validations'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/filesystem/path_matcher'
 
 # Owns everything about the TEST_SOURCE_FILE() build directive's own path
 # content: collecting a test's raw directive strings, telling additive
@@ -20,8 +19,6 @@ require 'ceedling/test_invoker/test_build_validations'
 # becomes a real filepath.
 class TestSourceFileDirectiveResolver
 
-  include TestBuildValidations
-
   constructor :test_context_extractor, :file_finder, :configurator, :loginator
 
   # Splits a test's TEST_SOURCE_FILE() entries into files to add and files to
@@ -33,31 +30,33 @@ class TestSourceFileDirectiveResolver
   def resolve(test_filepath, context)
     raw = @test_context_extractor.lookup_build_directive_sources_list( test_filepath )
     additive, subtractive = raw.partition { |source| FilePathUtils.add_path?( source ) }
-
-    # A directive's own text is written directly in the test file, so its `..`, if
-    # any, is anchored to that same test file's own directory -- exactly as a
-    # directory-relative #include would be.
     anchor = File.dirname( test_filepath )
 
-    find = -> (source) {
-      stripped = FilePathUtils.no_aggregation_decorators( source )
-      @file_finder.find_build_input_file(
-        filepath: PathMatcher.resolve_relative( stripped, anchor: anchor ),
-        complain: :ignore,
-        context:  context
-      )
-    }
-
-    additive_sources = additive.map(&find).compact
+    additive_sources = additive.filter_map { |source| locate( source, anchor: anchor, context: context ) }
 
     subtractive_sources = subtractive.each_with_object({}) do |source, hash|
-      resolved = find.call( source )
+      resolved = locate( source, anchor: anchor, context: context )
       hash[resolved] = source unless resolved.nil?
     end
 
     return [additive_sources, subtractive_sources]
   end
 
+  # A TEST_SOURCE_FILE() entry must name a real, recognized file whether it adds or removes.
+  # A typo fails loudly on either side of the +:/-: convention, naming the test that holds
+  # it. Entries are found exactly as `resolve` finds them, so any entry a build uses passes.
+  def validate!(test:, test_filepath:, context:)
+    anchor = File.dirname( test_filepath )
+
+    @test_context_extractor.lookup_build_directive_sources_list( test_filepath ).each do |entry|
+      source = FilePathUtils.no_aggregation_decorators( entry )
+      validate_extension!( test, source )
+      next unless locate( entry, anchor: anchor, context: context ).nil?
+
+      raise CeedlingException.new( "File '#{source}' specified with TEST_SOURCE_FILE() in #{test} cannot be found in the source file collection" )
+    end
+  end
+
   # Applies this test's TEST_SOURCE_FILE("-:...") entries against the fully
   # assembled source list, regardless of how each removed file originally got
   # there -- the implicit header/source convention, a positive directive, or
@@ -75,4 +74,25 @@ class TestSourceFileDirectiveResolver
     return sources - subtractive.keys
   end
 
+  private
+
+  # An entry's text is written in its test file, so its `..`, if any, is anchored to that
+  # test file's directory, as a directory-relative #include is
+  def locate(entry, anchor:, context:)
+    stripped = FilePathUtils.no_aggregation_decorators( entry )
+    return @file_finder.find_build_input_file(
+      filepath: PathMatcher.resolve_relative( stripped, anchor: anchor ), complain: :ignore, context: context
+    )
+  end
+
+  def validate_extension!(test, source)
+    assembly = @configurator.test_build_use_assembly
+    return if @configurator.extension_source.match?( source )
+    return if assembly && @configurator.extension_assembly.match?( source )
+
+    extensions  = @configurator.extension_source.to_s
+    extensions += " or #{@configurator.extension_assembly}" if assembly
+    raise CeedlingException.new( "File '#{source}' specified with TEST_SOURCE_FILE() in #{test} is not a #{extensions} source file" )
+  end
+
 end

data/lib/ceedling/tool_executor.rb

@@ -189,8 +189,8 @@ class ToolExecutor
 
     # Handle array or anything else passed into method to be expanded in place of replacement operators
     case (to_process)
-      when Array then to_process.each {|value| build_string.concat( "#{element.sub(match, value.to_s)} " ) } if (to_process.size > 0)
-      else build_string.concat( element.sub(match, to_process.to_s) )
+      when Array then to_process.each {|value| build_string.concat( "#{substitute( element, match, value )} " ) } if (to_process.size > 0)
+      else build_string.concat( substitute( element, match, to_process ) )
     end
 
     # Handle inline ruby string substitution
@@ -256,7 +256,7 @@ class ToolExecutor
     # expand elements (whether string or array) into substitution string & replace escaped '\$'
     elements.flatten!
     elements.each do |element|
-      build_string.concat( substitution.sub(/([^\\]*)\$/, "\\1#{element}") ) # don't replace escaped '\$' but allow us to replace just a lonesome '$'
+      build_string.concat( substitute( substitution, /(?<!\\)\$/, element ) ) # don't replace escaped '\$' but allow us to replace just a lonesome '$'
       build_string.gsub!(/\\\$/, '$')
       build_string.concat(' ')
     end
@@ -264,6 +264,12 @@ class ToolExecutor
     return build_string.strip
   end
 
+  # Replaces the first match of pattern in template with value, taken literally. A
+  # replacement string would read a path's `\0`, `\1` or `\\` as a back-reference.
+  def substitute(template, pattern, value)
+    return template.sub( pattern ) { value.to_s }
+  end
+
   def pretty_tool_name(command)
     # Titleize command's name -- each word capitalized plus underscores replaced with spaces
     name = "#{command[:name].split(/ |\_/).map(&:capitalize).join(" ")}"

data/lib/ceedling/yaml_wrapper.rb

@@ -82,8 +82,9 @@ class YamlWrapper
   # already picks the right calling convention for the installed Psych, so this should be
   # unreachable in practice; it exists as a last-resort safety net for an unanticipated
   # Psych version/interface mismatch, reported distinctly so it isn't mistaken for a user
-  # YAML-authoring error.
-  rescue ArgumentError => e
+  # YAML-authoring error. `::ArgumentError` names Ruby's own class, which the constructor
+  # gem's same-named class would otherwise shadow here.
+  rescue ::ArgumentError => e
     raise YamlLoadException.new(
       reason: :incompatible, source: source_label, original_error: e,
       message: "Installed Psych YAML library (#{Psych::VERSION}) does not support a safe-loading feature Ceedling requires ⏩️ #{e.message}"

data/lib/version.rb

@@ -21,7 +21,7 @@ module Ceedling
     # Target version for the current release cycle. Maintained by hand, one edit
     # per minor or major cycle. Never edited to match a release tag. The release
     # pipeline rewrites this line from the tag that triggered it.
-    BASE = '1.2.1'
+    BASE = '1.2.2'
 
     # Marker for a build the release pipeline did not produce. That pipeline
     # empties this line, so a published gem reports a bare version while a local

data/plugins/bullseye/config/defaults_bullseye.rb

@@ -51,7 +51,7 @@ DEFAULT_BULLSEYE_LINKER_TOOL = {
   }
 
 DEFAULT_BULLSEYE_FIXTURE_TOOL = {
-  :executable => '${1}'.freeze,
+  :executable => '"${1}"'.freeze, # Test executable, quoted as a path
   :name => 'default_bullseye_fixture'.freeze,
   :optional => false.freeze,
   :arguments => [].freeze

data/plugins/bullseye/lib/bullseye.rb

@@ -220,7 +220,7 @@ class Bullseye < Plugin
       end
 
       header = "Untested source files not in the coverage report (:untested_sources is :list):"
-      @loginator.log_list( untested_sources.sort, header, Verbosity::COMPLAIN, LogLabels::WARNING )
+      @loginator.log_list( untested_sources.sort, header, Verbosity::COMPLAIN )
 
     when BULLSEYE_UNTESTED_SOURCES_COMPILE
       untested_sources = collect_untested_sources( sources )
@@ -236,7 +236,7 @@ class Bullseye < Plugin
       untested_sources.each do |filepath|
         filename     = File.basename(filepath)
         object       = @ceedling[:file_path_utils].form_test_object_filepath( filepath, context: BULLSEYE_SYM )
-        dependencies = @ceedling[:file_path_utils].form_test_dependencies_filepath( filepath, context: BULLSEYE_SYM )
+        dependencies = @ceedling[:file_path_utils].form_test_dependencies_filepath( object, context: BULLSEYE_SYM )
         search_paths = @configurator.collection_paths_include
         # Defines and flags resolve as a tested source's do, against this source's filepath
         flags        = @ceedling[:test_build_setup].flags( context: BULLSEYE_SYM, operation: OPERATION_COMPILE_SYM, filepath: filepath )
@@ -263,6 +263,9 @@ class Bullseye < Plugin
           next
         end
 
+        @file_wrapper.mkdir( File.dirname( object ) )
+        @file_wrapper.mkdir( File.dirname( dependencies ) )
+
         begin
           @ceedling[:generator].generate_object_file_c(
             tool:         TOOLS_BULLSEYE_COMPILER,
@@ -559,11 +562,10 @@ class Bullseye < Plugin
     coverage_sources = []
     @test_invoker.each_test_with_sources { |_, srcs| coverage_sources.concat( srcs ) }
     coverage_sources.uniq!
-    # Every configured source extension is a valid ending for a mock/ignored-source name,
-    # so the two are joined into one regex alternation rather than matching just one.
-    source_extensions = EXTENSION_SOURCE.to_a.map { |ext| Regexp.escape(ext) }.join('|')
-    coverage_sources.delete_if {|item| item =~ /#{@configurator.cmock_mock_prefix}.+(?:#{source_extensions})$/}
-    coverage_sources.delete_if {|item| item =~ /(?:#{BULLSEYE_IGNORE_SOURCES.join('|')})(?:#{source_extensions})$/}
+    # Every configured source extension is a valid ending for a mock/ignored-source name
+    source_extensions = EXTENSION_SOURCE.pattern
+    coverage_sources.delete_if {|item| item =~ /#{@configurator.cmock_mock_prefix}.+#{source_extensions}$/}
+    coverage_sources.delete_if {|item| item =~ /(?:#{BULLSEYE_IGNORE_SOURCES.join('|')})#{source_extensions}$/}
 
     coverage_sources.each do |source|
       command          = @ceedling[:tool_executor].build_command_line(TOOLS_BULLSEYE_REPORT_COVFN, [], source)

data/plugins/cppcheck/config/defaults_cppcheck.rb

@@ -16,7 +16,7 @@ DEFAULT_CPPCHECK_TOOL = {
   :optional => true.freeze,
   :arguments => [
     '-I"${1}"'.freeze,
-    '${2}'.freeze
+    '"${2}"'.freeze
   ].freeze
 }