ceedling 1.2.0 → 1.2.2

data/spec/units/{file_wrapper_spec.rb → filesystem/file_wrapper_spec.rb}

@@ -6,7 +6,8 @@
 # =========================================================================
 
 require 'spec_helper'
-require 'ceedling/file_wrapper'
+require 'tmpdir'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/system_wrapper'
 require 'ceedling/exceptions'
 
@@ -210,54 +211,175 @@ describe FileWrapper do
     end
   end
 
-  # Same transient-visibility race as #open_with_retry, here hitting FileUtils.cp_r's
-  # own internal stat-then-open sequence instead of a bare File.open (Issue #1292:
-  # a vendor destination briefly reporting the wrong file/directory type mid-copy).
-  # Stub-based, matching #open_with_retry's own spec above -- no real filesystem or
-  # timing involved.
-  describe '#cp_r_with_retry' do
+  # A transient error mid-copy, such as a file another process holds open on Windows, is
+  # retried; one that never clears names the file. An error retrying cannot clear fails at
+  # once (GH #1376). FileTree's own specs cover the walk and the healing.
+  describe '#sync_tree retries' do
     before(:each) do
       allow(@file_wrapper).to receive(:sleep)
     end
 
-    it 'behaves identically to #cp_r when nothing fails' do
-      allow(FileUtils).to receive(:cp_r)
+    def with_tree
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'src' )
+        FileUtils.mkdir_p( source )
+        File.write( File.join( source, 'unity.c' ), "int x;\n" )
+        yield source, File.join( dir, 'dest' )
+      end
+    end
 
-      @file_wrapper.cp_r_with_retry('/src/.', '/dest')
+    it 'copies without retrying when nothing fails' do
+      with_tree do |source, dest|
+        @file_wrapper.sync_tree( source, dest )
 
-      expect(FileUtils).to have_received(:cp_r).with('/src/.', '/dest')
-      expect(@file_wrapper).not_to have_received(:sleep)
+        expect( File.read( File.join( dest, 'unity.c' ) ) ).to eq( "int x;\n" )
+        expect(@file_wrapper).not_to have_received(:sleep)
+      end
     end
 
-    it 'retries past a SystemCallError and succeeds once the underlying copy stops raising' do
-      call_count = 0
-      allow(FileUtils).to receive(:cp_r) do
-        call_count += 1
-        raise Errno::EISDIR, 'transient' if call_count < 3
+    it 'retries past a transient error and succeeds once the copy stops raising' do
+      with_tree do |source, dest|
+        calls = 0
+        allow(@file_wrapper).to receive(:replace_file).and_wrap_original do |original, *args|
+          calls += 1
+          raise Errno::EACCES, 'transient' if calls < 3
+          original.call( *args )
+        end
+
+        @file_wrapper.sync_tree( source, dest )
+
+        expect( calls ).to eq( 3 )
+        expect(@file_wrapper).to have_received(:sleep).twice
+        expect( File.exist?( File.join( dest, 'unity.c' ) ) ).to be(true)
       end
+    end
 
-      @file_wrapper.cp_r_with_retry('/src/.', '/dest')
+    it 'raises a CeedlingException naming the destination once every retry is exhausted, and logs it' do
+      with_tree do |source, dest|
+        allow(@file_wrapper).to receive(:replace_file).and_raise( Errno::EACCES, 'still held open' )
 
-      expect(call_count).to eq(3)
-      expect(@file_wrapper).to have_received(:sleep).twice
+        expect { @file_wrapper.sync_tree( source, dest ) }.to raise_error( CeedlingException, /#{Regexp.escape( dest )}/ )
+        expect(@loginator).to have_received(:log).with( a_string_including( dest ), Verbosity::ERRORS, LogLabels::AUTO )
+        # Initial attempt plus one retry for each configured delay
+        expect(@file_wrapper).to have_received(:replace_file).exactly( FileWrapper::TRANSIENT_IO_RETRY_DELAYS.size + 1 ).times
+      end
     end
 
-    it 'raises a CeedlingException naming the destination and retry count once every retry is exhausted, and logs it' do
-      allow(FileUtils).to receive(:cp_r).and_raise(Errno::ENOTDIR, 'still wrong type')
+    it 'fails at once on an error retrying cannot clear' do
+      with_tree do |source, dest|
+        allow(@file_wrapper).to receive(:replace_file).and_raise( Errno::ENOTDIR, 'wrong type' )
 
-      expect { @file_wrapper.cp_r_with_retry('/src/.', '/dest') }.to raise_error(CeedlingException, /\/dest/)
-      expect(@loginator).to have_received(:log).with(a_string_including('/dest'), Verbosity::ERRORS)
-      # Initial attempt + one retry per configured delay.
-      expect(FileUtils).to have_received(:cp_r).exactly(FileWrapper::TRANSIENT_IO_RETRY_DELAYS.size + 1).times
+        expect { @file_wrapper.sync_tree( source, dest ) }.to raise_error( Errno::ENOTDIR )
+        expect(@file_wrapper).not_to have_received(:sleep)
+      end
     end
 
-    it 'does not retry a non-SystemCallError -- propagates immediately' do
-      allow(FileUtils).to receive(:cp_r).and_raise(ArgumentError, 'not transient')
+    it 'propagates an error that is not a SystemCallError without retrying' do
+      with_tree do |source, dest|
+        allow(@file_wrapper).to receive(:replace_file).and_raise( ArgumentError, 'not transient' )
 
-      expect {
-        @file_wrapper.cp_r_with_retry('/src/.', '/dest')
-      }.to raise_error(ArgumentError, 'not transient')
-      expect(@file_wrapper).not_to have_received(:sleep)
+        expect { @file_wrapper.sync_tree( source, dest ) }.to raise_error( ArgumentError, 'not transient' )
+        expect(@file_wrapper).not_to have_received(:sleep)
+      end
+    end
+  end
+
+  describe '#tree_files' do
+    it 'lists every regular file below a directory as full paths in sorted path order' do
+      Dir.mktmpdir do |dir|
+        ['a/b.c', 'a.c', '.hidden', 'dir[1]/x.c'].each do |name|
+          FileUtils.mkdir_p( File.dirname( File.join( dir, name ) ) )
+          File.write( File.join( dir, name ), name )
+        end
+
+        expect( @file_wrapper.tree_files( dir ) ).to eq( ['.hidden', 'a.c', 'a/b.c', 'dir[1]/x.c'].map { |name| File.join( dir, name ) } )
+      end
+    end
+  end
+
+  # The temporary copy beside the destination is the longest path replace_file writes
+  describe '#replace_file' do
+    it 'checks the length of its temporary path, then leaves only the destination' do
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'unity.h' )
+        destination = File.join( dir, 'out', 'unity.h' )
+        File.write( source, "int x;\n" )
+        FileUtils.mkdir_p( File.dirname( destination ) )
+        checked = []
+        allow(@file_wrapper).to receive(:check_path_length) { |path, **| checked << path }
+
+        @file_wrapper.replace_file( source, destination )
+
+        expect( checked.size ).to eq( 1 )
+        expect( File.dirname( checked.first ) ).to eq( File.dirname( destination ) )
+        expect( checked.first.length ).to be > destination.length
+        expect( Dir.children( File.dirname( destination ) ) ).to eq( ['unity.h'] )
+      end
+    end
+
+    # Windows refuses to rename over a read-only file
+    it 'leaves the destination owner-writable, from a read-only source over a read-only destination' do
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'unity.h' )
+        destination = File.join( dir, 'out', 'unity.h' )
+        File.write( source, "new\n" )
+        FileUtils.mkdir_p( File.dirname( destination ) )
+        File.write( destination, "old\n" )
+        File.chmod( 0o444, source )
+        File.chmod( 0o444, destination )
+        allow(@file_wrapper).to receive(:check_path_length)
+
+        @file_wrapper.replace_file( source, destination )
+
+        expect( File.read( destination ) ).to eq( "new\n" )
+        expect( File.stat( destination ).mode & 0o200 ).to eq( 0o200 )
+      end
+    end
+
+    it 'replaces a destination link without changing the mode of the file it names' do
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'unity.h' )
+        outside = File.join( dir, 'outside.h' )
+        destination = File.join( dir, 'out', 'unity.h' )
+        File.write( source, "new\n" )
+        File.write( outside, "outside\n" )
+        File.chmod( 0o444, outside )
+        FileUtils.mkdir_p( File.dirname( destination ) )
+        begin
+          File.symlink( outside, destination )
+        rescue NotImplementedError, SystemCallError => e
+          skip "symlinks are unavailable here (#{e.class})"
+        end
+        allow(@file_wrapper).to receive(:check_path_length)
+
+        @file_wrapper.replace_file( source, destination )
+
+        expect( File.read( destination ) ).to eq( "new\n" )
+        expect( File.stat( outside ).mode & 0o777 ).to eq( 0o444 )
+      end
+    end
+  end
+
+  describe '#mkdir_for' do
+    it 'makes every directory above a file and returns the filepath' do
+      Dir.mktmpdir do |dir|
+        filepath = File.join( dir, 'artifacts', 'test', 'unit', 'test_foo.log' )
+
+        expect( @file_wrapper.mkdir_for( filepath ) ).to eq( filepath )
+        expect( File.directory?( File.dirname( filepath ) ) ).to be true
+        expect( File.exist?( filepath ) ).to be false
+      end
+    end
+
+    it 'tolerates threads making the same directory at once' do
+      Dir.mktmpdir do |dir|
+        filepath = File.join( dir, 'a', 'b', 'c', 'test_foo.log' )
+
+        threads = Array.new( 8 ) { Thread.new { @file_wrapper.mkdir_for( filepath ) } }
+
+        expect { threads.each( &:join ) }.to_not raise_error
+        expect( File.directory?( File.dirname( filepath ) ) ).to be true
+      end
     end
   end
 

data/spec/units/{path_matcher_spec.rb → filesystem/path_matcher_spec.rb}

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'spec_helper'
-require 'ceedling/path_matcher'
+require 'ceedling/filesystem/path_matcher'
 require 'ceedling/exceptions'
 
 describe PathMatcher do
@@ -190,4 +190,15 @@ describe PathMatcher do
     end
   end
 
+
+  # A `.` segment names nothing (the path handling audit around GH #1370)
+  describe 'G9: `.` segments' do
+    it 'matches a query with a leading `./`' do
+      expect(PathMatcher.candidates( './foo.h', ['inc/foo.h'] )).to eq( ['inc/foo.h'] )
+    end
+
+    it 'matches a query with a `.` segment within it' do
+      expect(PathMatcher.candidates( 'sub/./bar.h', ['inc/sub/bar.h'] )).to eq( ['inc/sub/bar.h'] )
+    end
+  end
 end

data/spec/units/{path_mirror_spec.rb → filesystem/path_mirror_spec.rb}

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'spec_helper'
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
 
 describe PathMirror do
 
@@ -20,9 +20,9 @@ describe PathMirror do
       expect(described_class.relative_subdir('src/drivers/sensors/foo.c', ['src/**'])).to eq('drivers/sensors')
     end
 
-    it 'strips +:/-: aggregation decorators from configured roots before comparing' do
+    it 'strips a +: decorator, and never treats a -: exclusion as a root' do
       expect(described_class.relative_subdir('src/drivers/foo.c', ['+:src/**'])).to eq('drivers')
-      expect(described_class.relative_subdir('src/drivers/foo.c', ['-:src/**'])).to eq('drivers')
+      expect(described_class.relative_subdir('src/drivers/foo.c', ['-:src/**'])).to eq('')
     end
 
     it 'picks the most specific (longest) matching root when configured roots are nested' do
@@ -49,7 +49,7 @@ describe PathMirror do
     it 'produces the same result as .relative_subdir when roots are cleaned once upfront' do
       clean = described_class.clean_roots(['+:src/**', '-:src/legacy/**'])
       expect(described_class.relative_subdir_from_clean_roots('src/drivers/foo.c', clean)).to eq('drivers')
-      expect(described_class.relative_subdir_from_clean_roots('src/legacy/vendor/foo.c', clean)).to eq('vendor')
+      expect(described_class.relative_subdir_from_clean_roots('src/legacy/vendor/foo.c', clean)).to eq('legacy/vendor')
     end
 
     it 'drops decorated roots that clean to nothing' do
@@ -100,4 +100,32 @@ describe PathMirror do
       expect( PathMirror.path_segments('drivers//uart/') ).to eq(['drivers', 'uart'])
     end
   end
+
+  # Root matching across spellings of one place (GH #1370 and the path handling audit)
+  describe 'root containment' do
+    it 'G1 (#1370): never answers a subdirectory that climbs out, below a `..` root' do
+      subdir = PathMirror.relative_subdir( '../../../opt/vendor/inc/x.h', ['../**'] )
+
+      expect(subdir.split( '/' )).to_not include( '..' )
+    end
+
+    it 'G2: mirrors below a `./`-spelled root as below the plain one' do
+      expect(PathMirror.relative_subdir( 'src/a/x.c', ['./src/**'] )).to eq( 'a' )
+    end
+
+    it 'G2: mirrors below an absolute root spelling of a relative file\'s directory' do
+      expect(PathMirror.relative_subdir( 'src/a/x.c', [File.join( Dir.pwd, 'src/**' )] )).to eq( 'a' )
+    end
+
+    it 'G2: mirrors a file spelled relatively below an absolute root outside the working directory' do
+      file = File.join( '..', '..', 'opt', 'x', 'a', 'f.c' )
+      root = File.join( File.expand_path( '../..' ), 'opt', 'x', '**' )
+
+      expect(PathMirror.relative_subdir( file, [root] )).to eq( 'a' )
+    end
+
+    it 'G3: never treats a `-:` exclusion as a root' do
+      expect(PathMirror.relative_subdir( 'src/exp/sub/x.c', ['+:src/**', '-:src/exp'] )).to eq( 'exp/sub' )
+    end
+  end
 end

data/spec/units/filesystem/project_paths_spec.rb

@@ -0,0 +1,147 @@
+# =========================================================================
+#   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 'tmpdir'
+require 'fileutils'
+require 'ceedling/filesystem/project_paths'
+
+# GH #1370 and the path handling audit around it: one place spelled many ways compared
+# as text, so `..` "contained" paths above it and build files escaped the build directory
+describe ProjectPaths do
+  WINDOWS_ONLY = { if: Gem.win_platform? }.freeze
+  POSIX_ONLY   = { unless: Gem.win_platform? }.freeze
+
+  around(:each) do |example|
+    Dir.mktmpdir do |dir|
+      @ws = File.realpath( dir )
+      FileUtils.mkdir_p( File.join( @ws, 'app' ) )
+      Dir.chdir( File.join( @ws, 'app' ) ) { example.run }
+    end
+  end
+
+  describe '.standardize' do
+    it 'writes a path with forward slashes and no trailing separator' do
+      expect(ProjectPaths.standardize( " src\\drv\\ " )).to eq( 'src/drv' )
+    end
+
+    it 'reads `~` as the home directory, after any decorator' do
+      expect(ProjectPaths.standardize( '~/inc' )).to eq( File.join( Dir.home, 'inc' ) )
+      expect(ProjectPaths.standardize( '-:~/inc' )).to eq( "-:#{File.join( Dir.home, 'inc' )}" )
+    end
+
+    it 'leaves `~user` as written' do
+      expect(ProjectPaths.standardize( '~someone/inc' )).to eq( '~someone/inc' )
+    end
+
+    it 'keeps a filesystem root' do
+      expect(ProjectPaths.standardize( '/' )).to eq( '/' )
+    end
+
+    it 'reads `~` after a decorator and a space, and drops every trailing separator' do
+      expect(ProjectPaths.standardize( '+: ~/inc' )).to eq( "+:#{File.join( Dir.home, 'inc' )}" )
+      expect(ProjectPaths.standardize( 'src//' )).to eq( 'src' )
+    end
+  end
+
+  describe '.absolute' do
+    # Spelled as the full computation spells it, whatever the shortcut for a clean path
+    it 'spells a rooted path with a trailing separator or surrounding space without either' do
+      expect(ProjectPaths.absolute( '/a/' )).to eq( '/a' ) unless Gem.win_platform?
+      expect(ProjectPaths.absolute( " #{@ws}/x " )).to eq( "#{@ws}/x" )
+    end
+
+    it 'reads `~user` as a directory of that name, never the user\'s home' do
+      expect(ProjectPaths.absolute( '~nosuchuser/inc' )).to eq( File.join( @ws, 'app', '~nosuchuser/inc' ) )
+    end
+
+    it 'reads a doubled leading separator as the filesystem root', **POSIX_ONLY do
+      expect(ProjectPaths.absolute( '//usr/include' )).to eq( '/usr/include' )
+      expect(ProjectPaths.contains?( '/usr', '//usr/include' )).to be true
+    end
+
+    it 'keeps a UNC path\'s `..` below its share', **WINDOWS_ONLY do
+      expect(ProjectPaths.absolute( '//srv/sh/a/../../../x' )).to eq( '//srv/sh/x' )
+    end
+  end
+
+  describe '.canonical' do
+    it 'spells every form of one place alike' do
+      FileUtils.mkdir_p( 'src/drv' )
+      spellings = ['src/drv', './src/drv', 'src/drv/', 'src\\drv', File.join( @ws, 'app/src/drv' ), 'src/../src/drv']
+
+      expect(spellings.map { |spelling| ProjectPaths.canonical( spelling ) }.uniq).to eq( ['src/drv'] )
+    end
+
+    it 'resolves a symlink along the existing part of a path', **POSIX_ONLY do
+      FileUtils.mkdir_p( 'src' )
+      File.symlink( File.join( @ws, 'app' ), File.join( @ws, 'link' ) )
+
+      expect(ProjectPaths.canonical( File.join( @ws, 'link/src/not_yet' ) )).to eq( 'src/not_yet' )
+    end
+
+    it 'climbs to a place outside the project' do
+      expect(ProjectPaths.canonical( File.join( @ws, 'shared/src' ) )).to eq( '../shared/src' )
+    end
+  end
+
+  describe '.subdir_below' do
+    it 'names the directories from a root down to a path below it' do
+      expect(ProjectPaths.subdir_below( 'src', 'src/drv/uart' )).to eq( 'drv/uart' )
+      expect(ProjectPaths.subdir_below( 'src', 'src' )).to eq( '' )
+    end
+
+    it 'finds nothing below a root that only shares a path\'s leading text' do
+      expect(ProjectPaths.subdir_below( 'src', 'src2/x' )).to be_nil
+    end
+
+    it 'finds nothing below `..` for a path climbing past it' do
+      expect(ProjectPaths.subdir_below( '..', '../../vendor/inc' )).to be_nil
+      expect(ProjectPaths.subdir_below( '..', '../vendor/inc' )).to eq( 'vendor/inc' )
+    end
+
+    it 'compares every spelling of a root and a path' do
+      expect(ProjectPaths.subdir_below( './src', File.join( @ws, 'app/src/a' ) )).to eq( 'a' )
+      expect(ProjectPaths.subdir_below( File.join( @ws, 'app/src' ), 'src/a' )).to eq( 'a' )
+    end
+
+    it 'never answers a subdirectory that climbs or is absolute' do
+      roots = ['..', '../..', '.', 'src', File.join( @ws, 'vendor' ), '/']
+      paths = ['../../far/x', '../vendor/inc', 'src/a', '/opt/x', File.join( @ws, 'vendor/inc' )]
+
+      roots.product( paths ).each do |root, path|
+        subdir = ProjectPaths.subdir_below( root, path )
+        next if subdir.nil?
+
+        expect(subdir.split( '/' )).to_not include( '..' ), "#{root} below #{path}: #{subdir}"
+        expect(subdir).to_not start_with( '/' ), "#{root} below #{path}: #{subdir}"
+      end
+    end
+
+    it 'compares Windows paths without regard to case', **WINDOWS_ONLY do
+      expect(ProjectPaths.subdir_below( 'C:/Proj/Src', 'c:/proj/src/a' )).to eq( 'a' )
+    end
+  end
+
+  # A build asks for the working directory tens of thousands of times, and asking the
+  # operating system costs tens of microseconds on macOS
+  describe '.working_dir' do
+    it 'reads the working directory once, however often it is asked' do
+      ProjectPaths.working_dir
+      expect(Dir).not_to receive(:pwd)
+
+      3.times { expect(ProjectPaths.working_dir).to eq( File.join( @ws, 'app' ) ) }
+    end
+
+    it 'answers a remembered path without reading the working directory' do
+      ProjectPaths.absolute( 'src/drv' )
+      expect(Dir).not_to receive(:pwd)
+
+      expect(ProjectPaths.absolute( 'src/drv' )).to eq( File.join( @ws, 'app/src/drv' ) )
+    end
+  end
+end

data/spec/units/filesystem/working_dir_spec.rb

@@ -0,0 +1,71 @@
+# =========================================================================
+#   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 'tmpdir'
+require 'fileutils'
+require 'ceedling/filesystem/working_dir'
+require 'ceedling/filesystem/project_paths'
+
+describe WorkingDir do
+  around(:each) do |example|
+    Dir.mktmpdir do |dir|
+      @ws = File.realpath( dir )
+      FileUtils.mkdir_p( File.join( @ws, 'app/dep' ) )
+      Dir.chdir( File.join( @ws, 'app' ) ) { example.run }
+    end
+  end
+
+  describe '.path' do
+    it 'reads the working directory once, however often it is asked' do
+      WorkingDir.path
+      expect(Dir).not_to receive(:pwd)
+
+      3.times { expect(WorkingDir.path).to eq( File.join( @ws, 'app' ) ) }
+    end
+
+    it 'keeps answering for the directory Ceedling started in across a plain Dir.chdir' do
+      WorkingDir.path
+
+      answer = WorkingDirTracking.untracked { Dir.chdir( 'dep' ) { WorkingDir.path } }
+      expect(answer).to eq( File.join( @ws, 'app' ) )
+    end
+
+    # The spec suite's own Dir.chdir hook, which every in-process spec relies on
+    it 'answers for a directory a spec changes to' do
+      WorkingDir.path
+
+      expect(Dir.chdir( 'dep' ) { WorkingDir.path }).to eq( File.join( @ws, 'app/dep' ) )
+      expect(WorkingDir.path).to eq( File.join( @ws, 'app' ) )
+    end
+  end
+
+  # Untracked, so the spec suite's Dir.chdir hook can't do WorkingDir.chdir's work for it
+  describe '.chdir' do
+    around(:each) { |example| WorkingDirTracking.untracked { example.run } }
+
+    before(:each) do
+      WorkingDir.path
+    end
+
+    it 'answers for the directory it changes to, then for the one it left' do
+      inside = WorkingDir.chdir( 'dep' ) { [WorkingDir.path, ProjectPaths.canonical( File.join( @ws, 'app/dep/x' ) )] }
+
+      expect(inside).to eq( [File.join( @ws, 'app/dep' ), 'x'] )
+      expect(WorkingDir.path).to eq( File.join( @ws, 'app' ) )
+      expect(ProjectPaths.canonical( File.join( @ws, 'app/dep/x' ) )).to eq( 'dep/x' )
+    end
+
+    it 'answers for the directory it left after a block that raises' do
+      inside = nil
+      expect { WorkingDir.chdir( 'dep' ) { inside = WorkingDir.path; raise 'failed' } }.to raise_error( 'failed' )
+
+      expect(inside).to eq( File.join( @ws, 'app/dep' ) )
+      expect(WorkingDir.path).to eq( File.join( @ws, 'app' ) )
+    end
+  end
+end

data/spec/units/generators/generator_spec.rb

@@ -155,7 +155,13 @@ describe Generator do
 
     it 'has each simple backtrace rerun explained by the plugins' do
       run( use_backtrace: :simple )
-      expect(backtrace).to have_received(:do_simple).with( 'test_a.c', 'build/test_a.out', anything, [], context: :test, tool: :fixture, explain: kind_of(Proc) )
+      expect(backtrace).to have_received(:do_simple).with( 'test_a.c', 'build/test_a.out', anything, [], tool: :fixture, explain: kind_of(Proc) )
+    end
+
+    # GH #1364: same-named tests keep separate gdb logs
+    it 'places gdb backtraces by the test name' do
+      run( use_backtrace: :gdb )
+      expect(backtrace).to have_received(:do_gdb).with( 'test_a.c', 'build/test_a.out', anything, [], context: :test, test_name: 'test_a' )
     end
 
     # A tool that runs the reruns itself can't run under gdb
@@ -235,7 +241,7 @@ describe Generator do
     def generate(**extra)
       @generator.generate_mock(
         context: :test, mock: :mock_config, test: 'test_both', input_filepath: 'src/drivers/uart/config.h',
-        output_path: 'build/test/mocks/test_both/drivers/uart', **extra
+        output_path: 'build/test/mocks/test_both/drivers/uart', mock_root: 'build/test/mocks/test_both/drivers/uart', **extra
       )
     end
 
@@ -246,16 +252,16 @@ describe Generator do
       expect(@cmock).to have_received(:setup_mocks).with( 'src/drivers/uart/config.h', nil )
     end
 
-    # CMock writes below its root at the folder, so the root is the directory less the folder
-    it 'roots CMock above the folder and hands it the folder, which names the mock' do
-      generate( folder: 'drivers/uart' )
+    # CMock writes below its root at the folder
+    it 'roots CMock where it is told and hands it the folder, which names the mock' do
+      generate( folder: 'drivers/uart', mock_root: 'build/test/mocks/test_both' )
 
       expect(@generator_mocks).to have_received(:build_configuration).with( 'build/test/mocks/test_both', overrides: {} )
       expect(@cmock).to have_received(:setup_mocks).with( 'src/drivers/uart/config.h', 'drivers/uart' )
     end
 
     it 'still reports the mock\'s own directory to plugins' do
-      generate( folder: 'drivers/uart' )
+      generate( folder: 'drivers/uart', mock_root: 'build/test/mocks/test_both' )
 
       expect(@plugin_manager).to have_received(:pre_mock_generate).with( hash_including( output_path: 'build/test/mocks/test_both/drivers/uart' ) )
     end