ceedling 1.2.1 → 1.2.2

data/spec/integration/actionator_file_operations_spec.rb

@@ -23,8 +23,9 @@
 
 require 'spec_helper'
 require 'spec_integration_helper'
+require 'file_tree_helper'
 require 'actionator'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 
 describe 'Actionator file operations (integration)' do
   include IntegrationSpecHelpers
@@ -144,6 +145,95 @@ describe 'Actionator file operations (integration)' do
         ])
       end
     end
+
+    # Status lines follow a sorted listing of full paths, so a file sorts ahead of the
+    # contents of a directory named like it
+    it 'reports files in sorted path order' do
+      with_source_tree({ 'tree/a/b.c' => 'b', 'tree/a.c' => 'a', 'tree/a-z.c' => 'z' }) do |dir|
+        actionator = build_actionator( dir )
+
+        actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+
+        expect(@loginator.lines).to eq([
+          '      create  out',
+          '      create  out/a-z.c',
+          '      create  out/a.c',
+          '      create  out/a/b.c',
+        ])
+      end
+    end
+
+    it 'leaves hidden files and hidden directories out' do
+      with_source_tree({ 'tree/keep.c' => 'k', 'tree/.rspec' => 'r', 'tree/.hidden/x.c' => 'x' }) do |dir|
+        actionator = build_actionator( dir )
+
+        actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+
+        expect(Dir.children( File.join( dir, 'out' ) )).to eq( ['keep.c'] )
+      end
+    end
+
+    it 'never enters a hidden directory, so nothing inside one stops the copy' do
+      with_source_tree({ 'tree/keep.c' => 'k', 'tree/.venv/x.c' => 'x' }) do |dir|
+        begin
+          File.symlink( File.join( dir, 'nowhere' ), File.join( dir, 'tree', '.venv', 'dangling.c' ) )
+        rescue NotImplementedError, SystemCallError => e
+          skip "symlinks are unavailable here (#{e.class})"
+        end
+        actionator = build_actionator( dir )
+
+        actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+
+        expect(Dir.children( File.join( dir, 'out' ) )).to eq( ['keep.c'] )
+      end
+    end
+
+    it 'copies a file below a directory named with glob metacharacters' do
+      with_source_tree({ 'tree/dir[1]/a{b}.c' => 'odd' }) do |dir|
+        actionator = build_actionator( dir )
+
+        actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+
+        expect(File.read( File.join( dir, 'out', 'dir[1]', 'a{b}.c' ) )).to eq( 'odd' )
+      end
+    end
+
+    # GH #1376: the tree is listed and classified without lstat, and a linked directory's
+    # contents are copied
+    it 'descends a linked directory' do
+      with_source_tree({ 'elsewhere/inner.c' => 'inner', 'tree/keep.c' => 'k' }) do |dir|
+        begin
+          File.symlink( File.join( dir, 'elsewhere' ), File.join( dir, 'tree', 'linked' ) )
+        rescue NotImplementedError, SystemCallError => e
+          skip "symlinks are unavailable here (#{e.class})"
+        end
+        actionator = build_actionator( dir )
+
+        actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+
+        expect(File.read( File.join( dir, 'out', 'linked', 'inner.c' ) )).to eq( 'inner' )
+      end
+    end
+
+    it 'copies every file as a file when lstat reports files as directories' do
+      with_source_tree({ 'tree/unity.c' => 'u', 'tree/sub/unity.h' => 'h' }) do |dir|
+        actionator = build_actionator( dir )
+        allow(File).to receive(:lstat).and_wrap_original do |original, path, *rest|
+          status = original.call( path, *rest )
+          path.to_s.include?( '/tree/' ) ? FileTreeHelper::LyingStat.new( status ) : status
+        end
+
+        begin
+          actionator.copy_directory( 'tree', File.join( dir, 'out' ), force: true )
+        ensure
+          # The temporary directory is removed by an lstat-based remover
+          allow(File).to receive(:lstat).and_call_original
+        end
+
+        expect(File.file?( File.join( dir, 'out', 'unity.c' ) )).to be true
+        expect(File.file?( File.join( dir, 'out', 'sub', 'unity.h' ) )).to be true
+      end
+    end
   end
 
   describe 'copy_file' do

data/spec/integration/compile_commands_json_db_spec.rb

@@ -17,7 +17,7 @@ require 'json'
 require 'tmpdir'
 require 'ceedling/constants'
 require 'ceedling/plugins/plugin'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 
 $: << File.expand_path('../../../plugins/compile_commands_json_db/lib', __FILE__)
 require 'compile_commands_json_db'

data/spec/integration/configurator_validation_spec.rb

@@ -20,7 +20,7 @@ describe 'Configurator validation (integration)' do
   include ConfigYamlHelper
   include ConfiguratorIntegrationHelpers
 
-  let(:validator) { configurator_objects( quiet_loginator )[:configurator_validator] }
+  let(:validator) { configurator_objects( quiet_loginator )[:configurator_paths_validator] }
 
   let(:files) do
     {

data/spec/integration/dependencies/dependency_tracker_cache_hardening_spec.rb

@@ -161,6 +161,32 @@ describe 'DependencyTracker cache hardening (integration)' do
       end
     end
 
+    # GH #1364: a build after upgrading from a version-1 layout rebuilds everything once, and
+    # the next build trusts the cache it then wrote
+    it 'rebuilds once after an upgrade from the version-1 build layout, then trusts its own cache' do
+      in_temp_dir do |dir|
+        store_path = File.join(dir, '.dep_cache.json')
+        target = write_fixture( File.join(dir, 'foo.o'), 'object bytes' )
+
+        write_fixture( store_path, JSON.generate(
+          'schema_version' => 1, 'hash_algorithm' => DependencyHasher::HASH_ALGORITHM,
+          'entries' => { target => { 'self_hash' => real_sha256(target), 'meta_hash' => nil, 'deps' => {} } }
+        ) )
+
+        upgraded = build_dependency_tracker( store_path: store_path )
+        upgraded.register( target, files: [] )
+        expect( upgraded.stale?( target ) ).to be(true)
+        upgraded.mark_fresh( target )
+        upgraded.flush
+
+        expect( JSON.parse( File.read( store_path ) )['schema_version'] ).to eq( DependencyCacheStore::CACHE_SCHEMA_VERSION )
+
+        rebuilt = build_dependency_tracker( store_path: store_path )
+        rebuilt.register( target, files: [] )
+        expect( rebuilt.stale?( target ) ).to be(false)
+      end
+    end
+
     # Same principle, but for a mismatched hash_algorithm field rather than
     # schema_version -- the two are independent, both-checked axes.
     it 'discards an entire cache whose hash_algorithm does not match' do

data/spec/integration/dependencies/dependency_tracker_core_spec.rb

@@ -242,6 +242,28 @@ describe 'DependencyTracker core tracking (integration)' do
     end
   end
 
+  # Staleness checks only the dependencies registered this build, so one dropped from the list
+  # leaves the rest as they were. A link registers the list itself as meta, which a shorter list
+  # changes, for when a source leaves the build.
+  it 'is stale when a dependency drops out of a list registered as meta' do
+    in_temp_dir do |dir|
+      store_path = File.join(dir, '.dep_cache.json')
+      kept       = write_fixture( File.join(dir, 'kept.o'), 'kept object' )
+      dropped    = write_fixture( File.join(dir, 'dropped.o'), 'dropped object' )
+      listed     = write_fixture( File.join(dir, 'listed.out'), 'executable bytes' )
+
+      first_run = build_dependency_tracker( store_path: store_path )
+      first_run.register( listed, files: [kept, dropped], meta: { objects: [kept, dropped] } )
+      first_run.mark_fresh( listed )
+      first_run.flush
+
+      second_run = build_dependency_tracker( store_path: store_path )
+      second_run.register( listed, files: [kept], meta: { objects: [kept] } )
+
+      expect( second_run.stale?( listed ) ).to be(true)
+    end
+  end
+
   # A delta build skips running an unchanged test executable and reports its cached results.
   # An executable linked with command line arguments enabled is identical with or without a
   # test case filter, so the fixture's own metadata must carry the filter (GH #1360).

data/spec/integration/launcher_handoff_spec.rb

@@ -0,0 +1,297 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# GH #1365: a launcher ran another installation's application inside its own process,
+# so the application ran on a mix of both installations' code. Each command must now
+# run whole in the installation it selects.
+#
+# The second installation is real: `new --local` vendors this repository into a
+# project, and the copy gains the assets and examples a vendored copy leaves out, so
+# it can also run `new` and `examples`. Two markers make it distinguishable from the
+# launcher:
+#  - Its lib/version.rb reports 9.9.9.
+#  - Its bin/ceedling reports, on exit, how many of the launcher's own files its
+#    process loaded. A whole hand-off loads none.
+#
+# Every command here stops short of compiling, so no toolchain is needed.
+
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+require 'open3'
+require 'rbconfig'
+require 'yaml'
+require 'ceedling/installation'
+
+describe 'Launcher hand-off' do
+  REPO_ROOT = File.expand_path( '../..', __dir__ )
+  LAUNCHER_VERSION = Installation.new( REPO_ROOT ).version
+
+  # Registered as the copy's launcher starts, so it reports on every exit, failures
+  # included. It prints to stderr, so `dumpconfig --stdout` output stays pure YAML.
+  MARKER = <<~RUBY
+    at_exit {
+      launcher_files = $LOADED_FEATURES.count { |f| f.start_with?( '%<lib>s' ) or f.start_with?( '%<bin>s' ) }
+      $stderr.puts( "LAUNCHER FILES LOADED: \#{launcher_files}" )
+    }
+  RUBY
+
+  def ceedling(*args, env: {}, dir: @project)
+    stdout, stderr, status = Open3.capture3(
+      {'CEEDLING_DECORATORS' => 'false'}.merge( env ),
+      RbConfig.ruby, File.join( REPO_ROOT, 'bin', 'ceedling' ), *args,
+      chdir: dir
+    )
+    return stdout, stderr, status
+  end
+
+  # The copy ran its own command, loading none of the launcher's files
+  def expect_copy_ran(stderr)
+    expect(stderr).to include( 'LAUNCHER FILES LOADED: 0' )
+  end
+
+  before(:all) do
+    @tmp = Dir.mktmpdir( 'handoff' )
+    _, stderr, status = ceedling( 'new', '--local', 'proj', dir: @tmp )
+    raise "Could not create a vendored project:\n#{stderr}" unless status.success?
+
+    @project = File.join( @tmp, 'proj' )
+    @copy = File.join( @project, 'vendor', 'ceedling' )
+
+    version_rb = File.join( @copy, 'lib', 'version.rb' )
+    File.write( version_rb, File.read( version_rb ).sub( /BASE = '[^']+'/, "BASE = '9.9.9'" ) )
+    marker = format( MARKER, lib: File.join( REPO_ROOT, 'lib', 'ceedling' ), bin: File.join( REPO_ROOT, 'bin' ) )
+    launcher = File.join( @copy, 'bin', 'ceedling' )
+    shebang, rest = File.read( launcher ).split( "\n", 2 )
+    File.write( launcher, [shebang, marker, rest].join( "\n" ) )
+
+    ['assets', 'examples'].each { |dir| FileUtils.cp_r( File.join( REPO_ROOT, dir ), @copy ) }
+
+    @copy_version = Installation.new( @copy ).version
+  end
+
+  after(:all) do
+    FileUtils.rm_rf( @tmp )
+  end
+
+  it 'gives the copy a distinct version' do
+    expect(@copy_version).to eq( '9.9.9.dev' )
+    expect(@copy_version).to_not eq( LAUNCHER_VERSION )
+  end
+
+  describe '`version`' do
+    it 'reports both installations for a project whose :which_ceedling selects the copy' do
+      stdout, _, status = ceedling( 'version' )
+
+      expect(status.exitstatus).to eq( 0 )
+      expect(stdout).to include( "Ceedling Launcher => #{LAUNCHER_VERSION}" )
+      expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+    end
+
+    it 'reports the copy that WHICH_CEEDLING selects, with no project' do
+      stdout, _, _ = ceedling( 'version', env: {'WHICH_CEEDLING' => @copy}, dir: @tmp )
+
+      expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+    end
+
+    it 'reports the copy that a project named with --project selects, from elsewhere' do
+      Dir.mktmpdir do |elsewhere|
+        # :which_ceedling resolves against the working directory, so name the copy absolutely
+        mixin = File.join( elsewhere, 'which.yml' )
+        File.write( mixin, {:project => {:which_ceedling => @copy}}.to_yaml )
+
+        stdout, _, _ = ceedling( 'version', '--project', File.join( @project, 'project.yml' ), '--mixin', mixin, dir: elsewhere )
+
+        expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+      end
+    end
+
+    it 'never hands off' do
+      _, stderr, _ = ceedling( 'version' )
+
+      expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+    end
+  end
+
+  describe 'project commands' do
+    it '`check` runs in the copy, with notices from both sides naming both versions' do
+      stdout, stderr, status = ceedling( 'check' )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(stdout).to include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is handing off to Ceedling #{@copy_version} at #{File.realpath( @copy )}/" ).or(
+        include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is handing off to Ceedling #{@copy_version} at #{@copy}/" )
+      )
+      expect(stdout).to match( /Ceedling #{Regexp.escape( @copy_version )} at .+ is now running, launched from Ceedling #{Regexp.escape( LAUNCHER_VERSION )} at #{Regexp.escape( REPO_ROOT )}\// )
+    end
+
+    ['environment', 'help', '-T'].each do |command|
+      it "`#{command}` runs in the copy" do
+        stdout, stderr, status = ceedling( command )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect_copy_ran( stderr )
+      end
+    end
+
+    it '`help` shows the copy\'s version in its footer' do
+      stdout, _, _ = ceedling( 'help' )
+
+      expect(stdout).to include( "Ceedling Packet User Manual (v#{@copy_version})" )
+    end
+
+    it '`dumpconfig --stdout` runs in the copy and writes nothing but YAML to stdout' do
+      stdout, stderr, status = ceedling( 'dumpconfig', '--stdout' )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(YAML.safe_load( stdout, permitted_classes: [Symbol] )).to include( :project )
+    end
+
+    it '`dumpconfig --no-app` runs in the copy' do
+      _, stderr, status = ceedling( 'dumpconfig', '--no-app', File.join( @tmp, 'dump.yml' ) )
+
+      expect(status.exitstatus).to eq( 0 ), stderr
+      expect_copy_ran( stderr )
+    end
+
+    it 'exits with the copy\'s failing status' do
+      Dir.mktmpdir do |mixins|
+        bad = File.join( mixins, 'bad.yml' )
+        File.write( bad, {:plugins => {:enabled => ['no_such_plugin']}}.to_yaml )
+
+        _, stderr, status = ceedling( 'check', '--mixin', bad )
+
+        expect(status.exitstatus).to eq( 1 )
+        expect_copy_ran( stderr )
+      end
+    end
+  end
+
+  describe 'commands without a project' do
+    it '`new` runs in the copy WHICH_CEEDLING selects, which vendors itself' do
+      Dir.mktmpdir do |dir|
+        _, stderr, status = ceedling( 'new', '--local', 'other', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect(status.exitstatus).to eq( 0 ), stderr
+        expect_copy_ran( stderr )
+        expect(Installation.new( File.join( dir, 'other', 'vendor', 'ceedling' ) ).version).to eq( @copy_version )
+        expect(File.read( File.join( dir, 'other', 'project.yml' ) )).to include( ":ceedling_version: #{@copy_version}" )
+      end
+    end
+
+    it '`examples` runs in the copy WHICH_CEEDLING selects' do
+      Dir.mktmpdir do |dir|
+        _, stderr, _ = ceedling( 'examples', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect_copy_ran( stderr )
+      end
+    end
+
+    it '`docs` exports the launcher\'s documentation, saying so, since the copy holds none' do
+      Dir.mktmpdir do |dir|
+        stdout, stderr, status = ceedling( 'docs', 'out', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+        expect(stdout).to include( "Ceedling #{@copy_version} at" )
+        expect(stdout).to include( "Exporting the documentation of Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ instead." )
+      end
+    end
+  end
+
+  describe '`upgrade`' do
+    it 'refuses to re-vendor a project from its own vendored copy' do
+      stdout, stderr, status = ceedling( 'upgrade', '.', env: {'WHICH_CEEDLING' => 'vendor/ceedling'} )
+
+      expect(status.exitstatus).to eq( 1 )
+      expect(stdout + stderr).to include( 'from itself' )
+      expect(File.directory?( @copy )).to be( true )
+    end
+  end
+
+  # A launcher before 1.2.2 loads the application into its own process. The application
+  # finishes the hand-off itself.
+  describe 'an application loaded into an older launcher\'s process' do
+    # Stands in for every 1.x launcher before 1.2.2: it builds its bin/ objects before
+    # Thor consumes ARGV, hands them over in CEEDLING_HANDOFF_OBJECTS, and requires the
+    # application's rakefile. Docker runs the real 1.0.0 through 1.2.1 launchers.
+    OLD_LAUNCHER = <<~RUBY
+      repo, app = ARGV.shift( 2 )
+      $LOAD_PATH.unshift( File.join( repo, 'bin' ) )
+      require 'app_cfg'
+      CEEDLING_APPCFG = CeedlingAppConfig.new
+      lib = CEEDLING_APPCFG[:ceedling_lib_path]
+      $LOAD_PATH.unshift( CEEDLING_APPCFG[:ceedling_lib_base_path], lib, File.join( lib, 'config' ), File.join( lib, 'filesystem' ),
+                          File.join( lib, 'rake_app' ), File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'diy', 'lib' ) )
+      require 'constructor'
+      require 'ceedling/constants'
+      require 'diy'
+      objects = DIY::Context.from_yaml( File.read( File.join( repo, 'bin', 'objects.yml' ) ) )
+      objects.build_everything
+      CEEDLING_HANDOFF_OBJECTS = [:rake_task_registry, :reportinator, :loginator, :file_wrapper, :yaml_wrapper,
+                                  :ruby_expandinator, :config_walkinator, :system_wrapper, :verbosinator].to_h { |n| [n, objects[n]] }
+      def boom_handler(_loginator, exception) = $stderr.puts( exception.message )
+      objects[:cli_helper].set_verbosity( Verbosity::NORMAL )
+      CEEDLING_APPCFG.set_paths( app )
+      require CEEDLING_APPCFG[:ceedling_rakefile_filepath]
+    RUBY
+
+    it 'restarts in its own process, with the original command line, saying so on both sides' do
+      script = File.join( @tmp, 'old_launcher.rb' )
+      File.write( script, OLD_LAUNCHER )
+
+      stdout, stderr, status = Open3.capture3(
+        {'CEEDLING_DECORATORS' => 'false'}, RbConfig.ruby, script, REPO_ROOT, @copy, 'check', chdir: @project
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(stdout).to include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ loaded Ceedling #{@copy_version}" )
+      expect(stdout).to include( "Restarting in Ceedling #{@copy_version}'s own process." )
+      expect(stdout).to include( 'Project configuration processed.' )
+    end
+
+    it 'warns and continues in that process when a hand-off already brought it there' do
+      stdout, stderr, status = ceedling(
+        'check', env: {'CEEDLING_HANDOFF_LAUNCHER' => '/elsewhere', 'CEEDLING_HANDOFF_TARGET' => REPO_ROOT}
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+      expect(stdout).to include( "Ceedling #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is now running, launched from Ceedling at #{File.expand_path( '/elsewhere' )}/." )
+      expect(stdout).to include( "loaded Ceedling #{@copy_version}" )
+      expect(stdout).to include( "Continuing in the launcher's process" )
+    end
+  end
+
+  describe 'the vendored copy' do
+    it 'runs on its own, holding the built-in mixins its launcher validates' do
+      stdout, stderr, status = Open3.capture3(
+        {'CEEDLING_DECORATORS' => 'false'}, RbConfig.ruby, File.join( @copy, 'bin', 'ceedling' ), 'check', chdir: @project
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect(File.directory?( File.join( @copy, Installation::BUILTIN_MIXINS_DIR ) )).to be( true )
+    end
+
+    # Windows has ceedling.cmd, whose %* passes the command tail intact
+    it 'takes arguments through its ./ceedling launch script exactly as typed', unless: Installation.windows? do
+      Dir.mktmpdir do |dir|
+        dump = File.join( dir, 'dump with spaces.yml' )
+
+        stdout, stderr, status = Open3.capture3(
+          {'CEEDLING_DECORATORS' => 'false'}, './ceedling', 'dumpconfig', '--no-app', '--mixin', "=:project:\n  :name: Two Words", dump,
+          chdir: @project
+        )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect(YAML.safe_load_file( dump, permitted_classes: [Symbol] )[:project][:name]).to eq( 'Two Words' )
+      end
+    end
+  end
+end

data/spec/integration/mixin_loading_spec.rb

@@ -50,7 +50,7 @@ require 'spec_helper'
 require 'tmpdir'
 require 'fileutils'
 require 'ceedling/constants'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/yaml_wrapper'
 require 'ceedling/ruby_expandinator'
 require 'ceedling/reportinator'

data/spec/integration/module_generator_spec.rb

@@ -21,8 +21,8 @@ require 'yaml'  # a Ceedling build always has YAML loaded
 require 'ceedling/constants'
 require 'ceedling/exceptions'
 require 'ceedling/plugins/plugin'
-require 'ceedling/file_finder_helper'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_finder_helper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/config/config_matchinator'
 require 'ceedling/defineinator'
 
@@ -249,7 +249,7 @@ describe 'Module Generator plugin (integration)' do
         File.write( 'src/old/a_file.c', '' )
         plugin = plugin_for( config )
         loginator = plugin.instance_variable_get( :@ceedling )[:loginator]
-        expect(loginator).to receive(:log).with( /`src\/a_file.c`.*`src\/old\/a_file.c`/, anything, anything )
+        expect(loginator).to receive(:log).with( /`src\/a_file.c`.*`src\/old\/a_file.c`/, Verbosity::COMPLAIN )
 
         capture_stdout { plugin.create( ModuleGeneratorRequest.new( name: 'a_file' ) ) }
 

data/spec/integration/nested_test_artifacts_spec.rb

@@ -0,0 +1,99 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Per-test logs placed by a test's name, written with real file I/O in a temporary project.
+# A test's name is its path from the project root, so its logs sit in subdirectories that
+# must exist before anything writes there (GH #1364). Same-named tests keep separate gdb
+# logs, each holding only its latest build's crash.
+
+require 'spec_helper'
+require 'tmpdir'
+require 'ceedling/constants'
+require 'ceedling/plugins/plugin'
+require 'ceedling/filesystem/file_wrapper'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/build_log_writer'
+
+$LOAD_PATH.unshift( File.expand_path( '../../plugins/report_tests_raw_output_log/lib', __dir__ ) )
+$LOAD_PATH.unshift( File.expand_path( '../../plugins/valgrind/lib', __dir__ ) )
+
+# Ceedling runtime path constants the plugins need at require time
+PROJECT_BUILD_ROOT           = 'build'              unless defined?(PROJECT_BUILD_ROOT)
+PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts'          unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
+PROJECT_TEST_RESULTS_PATH    = 'build/test/results' unless defined?(PROJECT_TEST_RESULTS_PATH)
+
+require 'report_tests_raw_output_log'
+require 'valgrind'
+
+describe 'Per-test logs of nested tests (integration)' do
+  let(:loginator)    { double( 'loginator', log: nil ) }
+  let(:file_wrapper) { FileWrapper.new( { loginator: loginator, verbosinator: double( 'verbosinator', should_output?: false ) } ) }
+
+  def in_project
+    Dir.mktmpdir( 'nested' ) do |root|
+      Dir.chdir( root ) do
+        stub_const( 'PROJECT_BUILD_ARTIFACTS_ROOT', 'build/artifacts' )
+        stub_const( 'VALGRIND_ARTIFACTS_PATH', 'build/artifacts/valgrind' )
+        yield
+      end
+    end
+  end
+
+  it 'writes the raw-output log of a test below its root' do
+    in_project do
+      objects = { file_wrapper: file_wrapper, loginator: loginator, reportinator: double( 'reportinator', generate_heading: '', generate_progress: '' ) }
+      plugin  = ReportTestsRawOutputLog.new( objects, 'report_tests_raw_output_log', '/plugins/report_tests_raw_output_log' )
+
+      plugin.post_test_fixture_execute( context: :test, test_name: 'test/unit/test_calc', shell_result: { output: "hello\n" } )
+      plugin.post_build( 0 )
+
+      expect( File.read( 'build/artifacts/test/test/unit/test_calc.raw.log' ) ).to include( 'hello' )
+    end
+  end
+
+  # Valgrind writes its own report at the --log-file path a build hands it
+  it "reads the Valgrind report of a test below its root" do
+    in_project do
+      stub_const( 'TOOLS_VALGRIND', { name: 'valgrind', executable: 'valgrind', arguments: [] } )
+      valgrind = Valgrind.allocate
+      {
+        configurator: double( 'configurator', project_config_hash: {} ), loginator: loginator, file_wrapper: file_wrapper,
+        dependinator: double( 'dependinator', register: nil ), mutex: Mutex.new, result_list: [], memory_errors: 0,
+        tests_processed: 0, reports_read: 0, explained: []
+      }.each { |name, value| valgrind.instance_variable_set( "@#{name}", value ) }
+
+      arg_hash = { context: VALGRIND_SYM, test_name: 'test/unit/test_calc', target: 'build/valgrind/out/test/unit/test_calc/test_calc.out', tool: {} }
+      valgrind.pre_test_fixture_register( arg_hash )
+
+      report = arg_hash[:tool][:arguments].find { |argument| argument.start_with?( '--log-file=' ) }[/"(.+)"/, 1]
+      File.write( report, "==1== ERROR SUMMARY: 2 errors from 2 contexts\n" )
+
+      valgrind.post_test_fixture_execute( context: VALGRIND_SYM, test_name: 'test/unit/test_calc', result_file: 'test_calc.pass' )
+
+      expect( report ).to eq( 'build/artifacts/valgrind/test/unit/test_calc.log' )
+      expect( valgrind.instance_variable_get( :@reports_read ) ).to eq( 1 )
+      expect( valgrind.instance_variable_get( :@memory_errors ) ).to eq( 2 )
+    end
+  end
+
+  it 'keeps the gdb logs of same-named tests apart, each holding only the latest build' do
+    in_project do
+      paths = FilePathUtils.new( configurator: double( 'configurator', project_log_path: 'build/logs' ), file_wrapper: file_wrapper )
+      logs  = ['test/a/test_crash', 'test/b/test_crash'].map { |name| paths.form_test_gdb_log( name, context: :test, name: 'test_boom' ) }
+
+      2.times do |build|
+        writer = BuildLogWriter.new( file_wrapper: file_wrapper )
+        logs.each { |log| writer.write( log, "=== test_boom ===\nbuild #{build} #{log}\n" ) }
+      end
+
+      expect( logs.uniq.size ).to eq( 2 )
+      logs.each do |log|
+        expect( File.read( log ) ).to eq( "=== test_boom ===\nbuild 1 #{log}\n" )
+      end
+    end
+  end
+end

data/spec/integration/partials_module_resolution_spec.rb

@@ -20,11 +20,11 @@
 # sharing a basename in different directories.
 
 require 'spec_helper'
-require 'ceedling/file_finder'
-require 'ceedling/file_finder_helper'
+require 'ceedling/filesystem/file_finder'
+require 'ceedling/filesystem/file_finder_helper'
 require 'ceedling/filename_extension'
-require 'ceedling/path_matcher'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/path_matcher'
+require 'ceedling/filesystem/file_path_utils'
 require 'ceedling/constants'
 
 describe 'Partial module resolution (integration)' do
@@ -50,6 +50,7 @@ describe 'Partial module resolution (integration)' do
     allow(@configurator).to receive(:extension_source).and_return( FilenameExtension.new('.c') )
     allow(@configurator).to receive(:collection_all_headers).and_return( RESOLUTION_HEADERS )
     allow(@configurator).to receive(:collection_all_source).and_return( RESOLUTION_SOURCES )
+    allow(@configurator).to receive(:collection_all_tests).and_return( [] )
 
     @finder = FileFinder.new({
       :configurator      => @configurator,
@@ -134,6 +135,8 @@ describe 'Partial module resolution (integration)' do
     before(:each) do
       allow(@configurator).to receive(:project_build_root).and_return('build')
       allow(@configurator).to receive(:paths_include).and_return( ['include/**'] )
+      allow(@configurator).to receive(:collection_mirror_roots_include).and_return( ['include'] )
+      allow(@configurator).to receive(:collection_mirror_roots_headers).and_return( ['include'] )
       allow(@configurator).to receive(:paths_source).and_return( ['src/**'] )
       allow(@configurator).to receive(:paths_support).and_return( [] )
       allow(@configurator).to receive(:release_build_use_assembly).and_return( false )