ceedling 1.1.10 → 1.2.0

data/lib/ceedling/file_path_collection_utils.rb

@@ -37,7 +37,12 @@ class FilePathCollectionUtils
       _path = FilePathUtils.no_aggregation_decorators( path )
 
       # If it's a glob, modify it for Ceedling's recursive subdirectory convention
-      _reformed = FilePathUtils::reform_subdirectory_glob( _path )
+      # #104 -- FilePathUtils.subdirectory_glob escapes a literal `[`/`]` in the
+      # user's own path before reforming the glob suffix, so it's matched literally
+      # rather than misread as glob character-class syntax. `_path` itself
+      # (unescaped) is still used below for suffix checks and decorator-stripping,
+      # neither of which is a glob operation.
+      _reformed = FilePathUtils.subdirectory_glob( _path )
 
       # Expand paths using Ruby's Dir.glob()
       #  - A simple path will yield that path
@@ -54,7 +59,7 @@ class FilePathCollectionUtils
       # Use _path (decorator-stripped) so the suffix check is not sensitive to +:/-: prefix format.
       # path.end_with? also works today (decorators are always prefixes, never suffixes),
       # but _path expresses the correct intent and removes the implicit coupling.
-      if _path.end_with?('/**') or _path.end_with?('/*')
+      if _path.end_with?('/**', '/*')
         parents = []
 
         dirs.each {|dir| parents << File.join(dir, '..')}
@@ -116,7 +121,9 @@ class FilePathCollectionUtils
 
       # Expand path by pattern as needed and add only filepaths to working list.
       # Sort for deterministic ordering — see collect_paths and Github Issue #860
-      @file_wrapper.directory_listing( path ).sort.each do |entry|
+      # #104 -- escape a literal `[`/`]` in the user's own path so it's matched
+      # literally rather than misread as glob character-class syntax.
+      @file_wrapper.directory_listing( FilePathUtils.escape_glob_brackets( path ) ).sort.each do |entry|
         filepaths << File.expand_path( entry ) if !@file_wrapper.directory?( entry )
       end
 
@@ -133,7 +140,13 @@ class FilePathCollectionUtils
     result_paths = (plus - minus).to_a
     result_paths.map! {|path| shortest_path_from_working(path) }
 
-    result = FileList.new( result_paths )
+    # #104 -- every entry here is already a concrete, real file (nothing left to glob-
+    # expand -- this method's whole job already resolved it from any actual glob), but
+    # plain FileList.new/#include re-interprets each entry as a glob pattern to
+    # re-resolve via Dir.glob regardless, silently dropping a literal `[`/`]` survivor
+    # all over again. FileWrapper#instantiate_file_list_literal (`<<`, not `.new`) adds
+    # every entry as-is, with no glob interpretation at all.
+    result = @file_wrapper.instantiate_file_list_literal( result_paths )
     result.resolve()  # Force expansion to prevent race conditions in threaded context
     return result
   end

data/lib/ceedling/file_path_utils.rb

@@ -11,12 +11,13 @@ require 'fileutils'
 require 'ceedling/exceptions'
 require 'ceedling/system_wrapper'
 require 'ceedling/constants'
+require 'ceedling/path_mirror'
 
 # global utility methods (for plugins, project files, etc.)
 def ceedling_form_filepath(destination_path, original_filepath, new_extension=nil)
   filename = File.basename(original_filepath)
   filename.replace(filename.ext(new_extension)) if (!new_extension.nil?)
-  return File.join( destination_path.gsub(/\\/, '/'), filename )
+  return File.join( destination_path.tr("\\", '/'), filename )
 end
 
 class FilePathUtils
@@ -32,7 +33,7 @@ class FilePathUtils
     if path.is_a? String
       raise CeedlingException.new("Attempted to standardize path in frozen string ⏩️ #{path.inspect}") if path.frozen?
       path.strip!
-      path.gsub!(/\\/, '/')
+      path.tr!("\\", '/')
       path.chomp!('/')
     end
     return path
@@ -80,6 +81,40 @@ class FilePathUtils
     return path[0..(find_index-1)]
   end
 
+  # #104 -- `[`/`]` are legal filename characters (Windows especially) but Ruby's
+  # `Dir.glob`/`File.fnmatch` treat an unescaped `[...]` as character-class glob
+  # syntax, so a literal bracket in a real directory name silently fails to match
+  # its own glob pattern. Ceedling has no glob-escape helper of its own and Ruby
+  # provides none for this (unlike `Regexp.escape` for regexes), so this backslash-
+  # escapes just those two characters. Callers apply this only to the raw,
+  # user-supplied path *segment* of a pattern they're about to build -- never to a
+  # glob suffix Ceedling itself appends (e.g. `'*.rb'`/`'**/*.c'`), which must stay
+  # glob-active.
+  def self.escape_glob_brackets(path)
+    return path if path.nil?
+    return path.gsub(/([\[\]])/) { "\\#{$1}" }
+  end
+
+  # #104 -- the single, canonical way to turn a (possibly bracket-containing) base
+  # directory path into a glob pattern safe for anything that (re-)interprets it as
+  # a glob (`FileWrapper#directory_listing`, `Rake::FileList#include`,
+  # `FileWrapper#instantiate_file_list`). `escape_glob_brackets` alone only protects
+  # a call site that remembers to invoke it -- several didn't, because building the
+  # pattern via a bare `File.join(path, suffix)` gives no signal escaping was ever
+  # needed. Routing every base-path-plus-suffix glob pattern through this instead
+  # makes that omission structurally harder to repeat.
+  def self.glob(base_path, *suffix)
+    return File.join( escape_glob_brackets( base_path ), *suffix )
+  end
+
+  # Same escaping guarantee as `glob`, for the one caller shape that reforms
+  # Ceedling's own trailing `/**` recursive-directory convention instead of
+  # appending a suffix. `reform_subdirectory_glob` only inspects/appends based on
+  # a trailing `**`, so escaping first doesn't interfere with its own logic.
+  def self.subdirectory_glob(path)
+    return reform_subdirectory_glob( escape_glob_brackets( path ) )
+  end
+
   # Return whether the given path is to be aggregated (no aggregation modifier defaults to same as +:).
   # nil is treated as an additive (non-excluding) path.
   def self.add_path?(path)
@@ -121,7 +156,7 @@ class FilePathUtils
 
     # Pair each original path with a normalized form used only for ancestry comparison.
     # Normalize to forward slashes and strip any trailing separator.
-    pairs = paths.map { |p| [p, p.gsub('\\', '/').chomp('/')] }
+    pairs = paths.map { |p| [p, p.tr('\\', '/').chomp('/')] }
 
     # Sort shallowest-first so ancestors are always encountered before their descendants.
     # No tiebreaker for same-depth entries needed: Ruby's sort_by doesn't guarantee a
@@ -144,24 +179,40 @@ class FilePathUtils
   ######### Instance methods ##########
 
   ### Release ###
-  def form_release_build_cache_path(filepath)
-    return File.join( @configurator.project_release_build_cache_path, File.basename(filepath) )
-  end
 
+  # `filepath` is an already-mirrored object path -- recovering the mirrored subdirectory
+  # beyond the release build output root and re-rooting it under the dependencies path
+  # keeps this dependencies file alongside the same-named object it accompanies, rather
+  # than colliding with another object's dependencies file at a shared flat basename.
   def form_release_dependencies_filepath(filepath)
-    return File.join( @configurator.project_release_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
+    subdir   = PathMirror.relative_subdir( filepath, [@configurator.project_release_build_output_path] )
+    basename = File.basename(filepath).ext(@configurator.extension_dependencies.primary)
+    root     = @configurator.project_release_dependencies_path
+    return subdir.empty? ? File.join(root, basename) : File.join(root, subdir, basename)
   end
 
   def form_release_build_objects_filelist(files)
-    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_path}/%n#{@configurator.extension_object}")
+    return mirror_build_objects(
+      files,
+      root:  @configurator.project_release_build_output_path,
+      ext:   @configurator.extension_object.primary,
+      roots: @configurator.paths_source
+    )
   end
 
+  # `filepath` is an already-mirrored object path -- its own directory is exactly where its
+  # list file belongs too, so no separate mirroring of its own is needed here.
   def form_release_build_list_filepath(filepath)
-    return File.join( @configurator.project_release_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
+    return File.join( File.dirname(filepath), File.basename(filepath).ext(@configurator.extension_list.primary) )
   end
 
   def form_release_dependencies_filelist(files)
-    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_dependencies_path}/%n#{@configurator.extension_dependencies}")
+    return mirror_build_objects(
+      files,
+      root:  @configurator.project_release_dependencies_path,
+      ext:   @configurator.extension_dependencies.primary,
+      roots: @configurator.paths_source
+    )
   end
 
   ### Tests ###
@@ -173,12 +224,19 @@ class FilePathUtils
   def form_test_object_filepath(filepath, name: nil, context: nil)
     File.join(
       form_build_context_path(BUILD_OUT_DIR, name: name, context: context),
-      File.basename(filepath).ext(@configurator.extension_object)
+      File.basename(filepath).ext(@configurator.extension_object.primary)
     )
   end
 
+  # As `form_test_runners_path`: a flat test's own identity forms the shared flat results
+  # directory, untouched -- only a genuinely nested test's own mirrored subdirectory
+  # becomes an extra directory level here, so two same-named tests land in distinct
+  # results directories without perturbing the overwhelmingly common flat, non-duplicate
+  # case.
   def form_test_results_path(name = nil, context: nil)
-    form_build_context_path(BUILD_RESULTS_DIR, context: context)
+    subdir = name.nil? ? '' : mirrored_test_subdir(name)
+    return form_build_context_path(BUILD_RESULTS_DIR, context: context) if subdir.empty?
+    return form_build_context_path(BUILD_RESULTS_DIR, name: subdir, context: context)
   end
 
   # Forms the filepath for the gdb backtrace log for a given test case.
@@ -195,11 +253,20 @@ class FilePathUtils
     form_build_context_path(BUILD_DEPENDENCIES_DIR, name: name, context: context)
   end
 
+  # `filepath` is an already-mirrored object path -- recovering the mirrored subdirectory
+  # beyond the test's own build root and re-rooting it under this test's dependencies path
+  # keeps this dependencies file alongside the same-named object it accompanies, rather
+  # than colliding with another object's dependencies file at a shared flat basename.
+  # Without a test identity to recover that build root from, there's no mirroring to do --
+  # the dependencies file stays exactly where its context-level directory alone places it.
   def form_test_dependencies_filepath(filepath, name: nil, context: nil)
-    File.join(
-      form_build_context_path(BUILD_DEPENDENCIES_DIR, name: name, context: context),
-      File.basename(filepath).ext(@configurator.extension_dependencies)
-    )
+    root     = form_build_context_path(BUILD_DEPENDENCIES_DIR, name: name, context: context)
+    basename = File.basename(filepath).ext(@configurator.extension_dependencies.primary)
+
+    return File.join(root, basename) if name.nil?
+
+    subdir = PathMirror.relative_subdir( filepath, [form_test_build_path(name, context: context)] )
+    return subdir.empty? ? File.join(root, basename) : File.join(root, subdir, basename)
   end
 
   def form_test_mocks_path(name, context: nil)
@@ -230,20 +297,50 @@ class FilePathUtils
     form_named_path(@configurator.project_test_preprocess_files_path, name, subdir: PREPROCESS_RAW_DIRECTIVES_ONLY_DIR)
   end
 
-  def form_test_build_cache_path(filepath)
-    return File.join( @configurator.project_test_build_cache_path, File.basename(filepath) )
+  def form_test_preprocess_build_directives_path(name, context: nil)
+    form_named_path(@configurator.project_test_preprocess_build_directives_path, name)
+  end
+
+  # Where a test file's own #include/build-directive scan results are cached, keyed by
+  # the test file's own name so each test's cache lives alongside its other
+  # preprocessing artifacts.
+  def form_test_build_directives_cache_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_build_directives_path, subdir, File.basename(filepath) + EXTENSION_CORE_YAML )
+  end
+
+  # Where a test file's TEST_SOURCE_FILE() results are cached once its preprocessed
+  # output has been generated -- kept distinct from the raw-file cache above since the
+  # two are populated at different points in the pipeline from different content.
+  def form_preprocessed_source_files_cache_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_build_directives_path, subdir, File.basename(filepath) + '_source_files' + EXTENSION_CORE_YAML )
   end
 
   def form_pass_results_filepath(build_output_path, filepath)
-    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testpass) )
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testpass.primary) )
   end
 
   def form_fail_results_filepath(build_output_path, filepath)
-    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testfail) )
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testfail.primary) )
+  end
+
+  # A flat test's own identity (no mirrored subdirectory of its own) forms the shared flat
+  # runners directory, untouched -- only a genuinely nested test's own mirrored
+  # subdirectory (excluding its own basename) becomes an extra directory level here, so two
+  # same-named tests in different directories land in distinct runner directories without
+  # perturbing the overwhelmingly common flat, non-duplicate case.
+  def form_test_runners_path(name, context: nil)
+    subdir = mirrored_test_subdir(name)
+    return @configurator.project_test_runners_path if subdir.empty?
+    return File.join(@configurator.project_test_runners_path, subdir)
   end
 
-  def form_runner_filepath_from_test(filepath)
-    return File.join( @configurator.project_test_runners_path, File.basename(filepath, @configurator.extension_source)) + @configurator.test_runner_file_suffix + EXTENSION_CORE_SOURCE
+  def form_runner_filepath_from_test(filepath, name: nil)
+    # Strip whatever extension the test file actually carries -- there's no need to consult
+    # the configured source extension(s) here, since the basename's own suffix is already
+    # known to be a valid one by the time a runner is being formed for it.
+    basename = File.basename(filepath, File.extname(filepath))
+    root = name ? form_test_runners_path(name) : @configurator.project_test_runners_path
+    return File.join( root, basename) + @configurator.test_runner_file_suffix + EXTENSION_CORE_SOURCE
   end
 
   def form_test_filepath_from_runner(filepath)
@@ -251,39 +348,123 @@ class FilePathUtils
   end
 
   def form_test_executable_filepath(build_output_path, filepath)
-    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_executable) )
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_executable.primary) )
   end
 
   def form_test_build_map_filepath(build_output_path, filepath)
-    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_map) )
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_map.primary) )
   end
 
+  # `filepath` is an already-mirrored object path -- its own directory is exactly where its
+  # list file belongs too, so no separate mirroring of its own is needed here.
   def form_test_build_list_filepath(filepath)
-    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
+    return File.join( File.dirname(filepath), File.basename(filepath).ext(@configurator.extension_list.primary) )
+  end
+
+  # A preprocessed artifact's name below its test's own subdirectory. The test subdirectory
+  # alone kept artifacts apart while a test had at most one source of any given basename.
+  # Two same-basename sources in one test overwrite each other, so the file's own namespace
+  # below its configured root is carried forward too.
+  #
+  # A file below none of those roots mirrors nothing and keeps the flat name it has always
+  # had. Ceedling's own generated files are the exception: `test` names which test's
+  # generated roots to measure against as well, since a mock or a Partial sits below one
+  # of those rather than anything the project configured. Every caller derives this from
+  # the same filepath, so all of them agree on where the artifact lands without
+  # coordinating.
+  def preprocessed_file_subpath(filepath, test = nil)
+    roots = @configurator.paths_source +
+            @configurator.paths_support +
+            @configurator.paths_include +
+            @configurator.paths_test +
+            generated_roots( test )
+
+    subdir   = PathMirror.relative_subdir( filepath, roots )
+    basename = File.basename( filepath )
+
+    return basename if subdir.empty?
+
+    return File.join( subdir, basename )
+  end
+
+  # The roots holding one test's own generated files. A mock or a generated Partial sits
+  # below one of these rather than a configured source root, and two same-named modules
+  # each produce one, so without these roots both share a single preprocessed artifact.
+  #
+  # Each root carries the test's own name, so what mirrors forward is the module's own
+  # subdirectory rather than the test name a second time.
+  def generated_roots(test)
+    return [] if test.nil?
+
+    roots = []
+    roots << File.join( @configurator.project_test_partials_path, test ) if @configurator.project_use_partials
+    roots << File.join( @configurator.cmock_mock_path, test ) if @configurator.project_use_mocks
+
+    return roots
+  end
+
+  # Composes a preprocessed artifact's path. Pure, like every other path builder here:
+  # callers that merely restate a path -- a rake target declaration, a staleness check --
+  # must not leave directories behind as a side effect. Whoever writes the file creates
+  # its directory, the same way a mock's or a Partial's own writer does.
+  def form_preprocessed_filepath(root, subdir, kind_dir, filepath, suffix: '')
+    return File.join( *[root, subdir, kind_dir, preprocessed_file_subpath( filepath, subdir ) + suffix].compact )
   end
 
   def form_preprocessed_includes_list_filepath(filepath, subdir)
-    return File.join( @configurator.project_test_preprocess_includes_path, subdir, File.basename(filepath) + @configurator.extension_yaml )
+    return form_preprocessed_filepath(
+      @configurator.project_test_preprocess_includes_path, subdir, nil, filepath, suffix: EXTENSION_CORE_YAML
+    )
   end
 
   def form_preprocessed_file_filepath(filepath, subdir)
-    return File.join( @configurator.project_test_preprocess_files_path, subdir, File.basename(filepath) )
+    return form_preprocessed_filepath( @configurator.project_test_preprocess_files_path, subdir, nil, filepath )
   end
 
   def form_preprocessed_file_full_expansion_filepath(filepath, subdir)
-    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_FULL_EXPANSION_DIR, File.basename(filepath) )
+    return form_preprocessed_filepath(
+      @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_FULL_EXPANSION_DIR, filepath
+    )
   end
 
   def form_preprocessed_file_raw_directives_only_filepath(filepath, subdir)
-    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_RAW_DIRECTIVES_ONLY_DIR, File.basename(filepath) )
+    return form_preprocessed_filepath(
+      @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_RAW_DIRECTIVES_ONLY_DIR, filepath
+    )
+  end
+
+  def form_preprocessed_file_fallback_expansion_filepath(filepath, subdir)
+    return form_preprocessed_filepath(
+      @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_FALLBACK_EXPANSION_DIR, filepath
+    )
   end
 
   def form_preprocessed_file_compacted_directives_only_filepath(filepath, subdir)
-    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_DIRECTIVES_ONLY_DIR, File.basename(filepath) )
+    return form_preprocessed_filepath(
+      @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_DIRECTIVES_ONLY_DIR, filepath
+    )
   end
 
-  def form_test_build_objects_filelist(path, sources)
-    return (@file_wrapper.instantiate_file_list(sources)).pathmap("#{path}/%n#{@configurator.extension_object}")
+  # `extra_roots` carries roots known only to the caller. A generated Partial source sits
+  # below its own test's build root rather than a configured source root, so nothing in the
+  # standard roots mirrors it. Without its root here, two modules sharing a basename
+  # collapse onto one object filename.
+  def form_test_build_objects_filelist(path, sources, extra_roots: [])
+    return mirror_build_objects(
+      sources,
+      root:  path,
+      ext:   @configurator.extension_object.primary,
+      roots: @configurator.paths_source + @configurator.paths_support + extra_roots
+    )
+  end
+
+  # Where one mock's generated files sit: its test's mock root, plus the subdirectory
+  # mirroring whatever it mocks. Shared by the stage that compiles a mock and the stage
+  # that generates it, so the two cannot disagree about where a mock lives.
+  def form_mock_output_path(root, subdir)
+    return root if subdir.nil? || subdir.empty?
+
+    return File.join( root, subdir )
   end
 
   def form_mock_header_filepath(subdir, filename)
@@ -292,48 +473,86 @@ class FilePathUtils
     return File.join(@configurator.cmock_mock_path, subdir, filename.ext(EXTENSION_CORE_HEADER))
   end
 
-  def form_mocks_source_filelist(path, mocks)
-    list = (@file_wrapper.instantiate_file_list(mocks))
-    return list.map{ |file| File.join(path, File.basename(file).ext(EXTENSION_CORE_SOURCE)) }
-  end
-
   def form_partial_header_filepath(subdir, filename)
     # @configurator.project_test_partials_path accessor only exists if partials are enabled
     raise CeedlingException.new('Partials are not enabled, but an internal feature dependent on them was accessed.') unless @configurator.project_use_partials
     return File.join( @configurator.project_test_partials_path, subdir, filename.ext(EXTENSION_CORE_HEADER) )
   end
 
+  # Every generated Partial filename below is also the text a Partial directive macro
+  # expands to, so the two have to agree exactly or the compiler resolves the generated
+  # #include to nothing.
+  #
+  # A module named by directory keeps that directory and takes its prefixes on the
+  # basename, matching how the macro assembles the same name. Concatenating the whole
+  # module name instead would put the prefix on the first path segment.
+  def form_partial_filename(_module, suffix, extension, prefix: '')
+    dir      = File.dirname( _module )
+    basename = prefix + PARTIAL_FILENAME_PREFIX + File.basename( _module ) + suffix + extension
+
+    return basename if dir == '.'
+
+    return File.join( dir, basename )
+  end
+
+  # Reverses form_partial_filename(). A generated Partial filename is Ceedling's own
+  # invention, so a message naming one tells a test author nothing. Recovering the module
+  # lets a message name what the author actually wrote.
+  #
+  # Prefixes stack on a mocked interface header, mock outermost. The suffix is stripped
+  # from the end only, so a module whose own name ends in a suffix word survives. Returns
+  # nil for any filename this builder could not have produced.
+  def module_from_partial_filename(filepath)
+    dir      = File.dirname( filepath )
+    basename = File.basename( filepath ).ext('')
+
+    basename = basename.delete_prefix( @configurator.cmock_mock_prefix )
+
+    return nil unless basename.start_with?( PARTIAL_FILENAME_PREFIX )
+
+    basename = basename.delete_prefix( PARTIAL_FILENAME_PREFIX )
+
+    suffix = PARTIAL_FILENAME_SUFFIXES.find { |candidate| basename.end_with?( candidate ) }
+
+    return nil if suffix.nil?
+
+    basename = basename.delete_suffix( suffix )
+
+    return basename if dir == '.'
+
+    return File.join( dir, basename )
+  end
+
   def form_partial_interface_header_filename(_module)
-    return PARTIAL_FILENAME_PREFIX + _module + '_interface' + EXTENSION_CORE_HEADER
+    return form_partial_filename( _module, PARTIAL_SUFFIX_INTERFACE, EXTENSION_CORE_HEADER )
   end
 
   # A module's typedefs and aggregate (struct/enum/union) definitions are generated into this
   # standalone header, shared by both the implementation and interface headers below, so a
   # module tested and mocked in the same file never has its types defined more than once.
   def form_partial_types_header_filename(_module)
-    return PARTIAL_FILENAME_PREFIX + _module + '_types' + EXTENSION_CORE_HEADER
+    return form_partial_filename( _module, PARTIAL_SUFFIX_TYPES, EXTENSION_CORE_HEADER )
   end
 
   def form_mock_partial_interface_header_filename(_module)
-    return @configurator.cmock_mock_prefix + PARTIAL_FILENAME_PREFIX + _module + '_interface' + EXTENSION_CORE_HEADER
+    return form_partial_filename( _module, PARTIAL_SUFFIX_INTERFACE, EXTENSION_CORE_HEADER, prefix: @configurator.cmock_mock_prefix )
   end
 
   def form_partial_implementation_header_filename(_module)
-    return PARTIAL_FILENAME_PREFIX + _module + '_impl' + EXTENSION_CORE_HEADER
+    return form_partial_filename( _module, PARTIAL_SUFFIX_IMPL, EXTENSION_CORE_HEADER )
   end
 
   def form_partial_implementation_source_filename(_module)
-    return PARTIAL_FILENAME_PREFIX + _module + '_impl' + EXTENSION_CORE_SOURCE
-  end
-
-  def form_test_dependencies_filelist(files)
-    list = @file_wrapper.instantiate_file_list(files)
-    return list.pathmap("#{@configurator.project_test_dependencies_path}/%n#{@configurator.extension_dependencies}")
+    return form_partial_filename( _module, PARTIAL_SUFFIX_IMPL, EXTENSION_CORE_SOURCE )
   end
 
   def form_pass_results_filelist(path, files)
-    list = @file_wrapper.instantiate_file_list(files)
-    return list.pathmap("#{path}/%n#{@configurator.extension_testpass}")
+    return mirror_build_objects(
+      files,
+      root:  path,
+      ext:   @configurator.extension_testpass.primary,
+      roots: @configurator.paths_test
+    )
   end
 
   ### Private ###
@@ -346,13 +565,52 @@ class FilePathUtils
     parts << context.to_s if context
     parts << subdir
     parts << name if name
-    File.join( *parts )
+    path = File.join( *parts )
+    @file_wrapper.check_path_length( path, origin: 'FilePathUtils#form_build_context_path' )
+    return path
   end
 
   # Forms base/name[/subdir]
   def form_named_path(base, name, subdir: nil)
-    return File.join( base, name, subdir ) if subdir
-    File.join( base, name )
+    path = subdir ? File.join( base, name, subdir ) : File.join( base, name )
+    @file_wrapper.check_path_length( path, origin: 'FilePathUtils#form_named_path' )
+    return path
+  end
+
+  # The mirrored-subdirectory portion of a test's own identity, excluding its own basename
+  # -- '' for a flat test (e.g. 'TestFoo', no subdirectory at all), or the leading segments
+  # for a nested one (e.g. 'unit' for 'unit/test_foo').
+  def mirrored_test_subdir(name)
+    dir = File.dirname(name)
+    return '' if dir == '.'
+    return dir
+  end
+
+  # Maps each file to root/[mirrored subdir/]basename.ext, mirroring whichever configured
+  # root in `roots` the file lives under -- e.g. a source file in a second configured
+  # source directory lands in its own mirrored subdirectory rather than colliding with a
+  # same-named object from the first. A file matching none of `roots` (a mock's own bare
+  # basename, a vendor framework file, the test file itself under its own build path) is
+  # left flat under `root`.
+  # #104 -- `files` (and, below, the `objects` this method itself computes) are already
+  # fully concrete filepaths -- nothing to glob-expand, no search to perform -- but
+  # `objects`' own entries in particular don't exist on disk yet at all (they're this
+  # very build's *about-to-be-compiled* output). FileWrapper#instantiate_file_list
+  # (Rake::FileList.new/#include) treats every entry as a glob pattern to resolve via
+  # Dir.glob regardless, which can only ever match files that already exist -- so a
+  # not-yet-existing object path is silently dropped outright, independent of whether
+  # it contains a literal `[`/`]`. FileWrapper#instantiate_file_list_literal (`<<`, not
+  # `.new`/`.include`) adds every entry as-is, with no glob interpretation at all -- the
+  # correct construction for a list that's already the real, final answer.
+  def mirror_build_objects(files, root:, ext:, roots:)
+    clean_roots = PathMirror.clean_roots( roots )
+
+    objects = @file_wrapper.instantiate_file_list_literal(files).map do |file|
+      subdir   = PathMirror.relative_subdir_from_clean_roots( file, clean_roots )
+      basename = File.basename(file).ext(ext)
+      subdir.empty? ? File.join(root, basename) : File.join(root, subdir, basename)
+    end
+    return @file_wrapper.instantiate_file_list_literal( objects )
   end
 
 end