ceedling 1.2.1 → 1.2.2

data/spec/units/installation_spec.rb

@@ -0,0 +1,228 @@
+# =========================================================================
+#   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/installation'
+
+describe Installation do
+  # Each 1.x release shape of lib/version.rb, as published (stamped DEV) or built locally
+  VERSION_1_1 = <<~RUBY
+    module Ceedling
+      module Version
+        GEM = '1.1.10'
+        TAG = GEM
+        puts( TAG ) if (__FILE__ == $0)
+      end
+    end
+  RUBY
+
+  VERSION_1_2 = <<~RUBY
+    module Ceedling
+      module Version
+        BASE = '1.2.0'
+        DEV = '.dev'
+        GEM = BASE.end_with?( DEV ) ? BASE : "\#{BASE}\#{DEV}"
+        TAG = GEM
+        puts( TAG ) if (__FILE__ == $0)
+      end
+    end
+  RUBY
+
+  def write_version(root, text)
+    FileUtils.mkdir_p( File.join( root, 'lib' ) )
+    File.write( File.join( root, 'lib', 'version.rb' ), text )
+  end
+
+  describe '#version' do
+    it 'reads the GEM/TAG format of 1.0 and 1.1' do
+      Dir.mktmpdir do |root|
+        write_version( root, VERSION_1_1 )
+
+        expect(described_class.new( root ).version).to eq( '1.1.10' )
+      end
+    end
+
+    it 'reads the BASE/DEV format of 1.2 for a local build' do
+      Dir.mktmpdir do |root|
+        write_version( root, VERSION_1_2 )
+
+        expect(described_class.new( root ).version).to eq( '1.2.0.dev' )
+      end
+    end
+
+    it 'reads a release whose pipeline emptied DEV' do
+      Dir.mktmpdir do |root|
+        write_version( root, VERSION_1_2.sub( "DEV = '.dev'", "DEV = ''" ) )
+
+        expect(described_class.new( root ).version).to eq( '1.2.0' )
+      end
+    end
+
+    # GH #1365: the loaded constant belongs to whichever installation loaded first
+    it 'ignores the Ceedling::Version already loaded and leaves it untouched' do
+      Dir.mktmpdir do |root|
+        write_version( root, VERSION_1_1 )
+        stub_const( 'Ceedling::Version::TAG', '9.9.9' )
+
+        expect(described_class.new( root ).version).to eq( '1.1.10' )
+        expect(Ceedling::Version::TAG).to eq( '9.9.9' )
+      end
+    end
+
+    it 'is nil when the installation has no lib/version.rb' do
+      Dir.mktmpdir do |root|
+        expect(described_class.new( root ).version).to be_nil
+      end
+    end
+
+    it 'is nil when lib/version.rb defines no Ceedling::Version::TAG' do
+      Dir.mktmpdir do |root|
+        write_version( root, "module Other; end\n" )
+
+        expect(described_class.new( root ).version).to be_nil
+      end
+    end
+
+    it 'is nil when lib/version.rb cannot be evaluated' do
+      Dir.mktmpdir do |root|
+        write_version( root, "module Ceedling\n" )
+
+        expect(described_class.new( root ).version).to be_nil
+      end
+    end
+  end
+
+  describe 'paths' do
+    it 'expands its root and derives the launcher and rakefile beneath it' do
+      Dir.mktmpdir do |root|
+        installation = described_class.new( File.join( root, 'x', '..' ) )
+
+        expect(installation.root).to eq( File.expand_path( root ) )
+        expect(installation.bin_path).to eq( File.join( File.expand_path( root ), 'bin', 'ceedling' ) )
+        expect(installation.rakefile_path).to eq( File.join( File.expand_path( root ), 'lib', 'ceedling', 'rakefile.rb' ) )
+      end
+    end
+  end
+
+  describe '#==' do
+    it 'treats a symlinked path and a trailing slash as the same installation' do
+      Dir.mktmpdir do |dir|
+        real = File.join( dir, 'real' )
+        link = File.join( dir, 'link' )
+        FileUtils.mkdir_p( real )
+        File.symlink( real, link )
+
+        expect(described_class.new( link )).to eq( described_class.new( real + '/' ) )
+      end
+    end
+
+    it 'distinguishes different directories' do
+      Dir.mktmpdir do |a|
+        Dir.mktmpdir do |b|
+          expect(described_class.new( a )).not_to eq( described_class.new( b ) )
+        end
+      end
+    end
+
+    it 'compares a path that does not exist by its expanded form' do
+      expect(described_class.new( '/no/such/ceedling' )).to eq( described_class.new( '/no/such/ceedling/' ) )
+      expect(described_class.new( '/no/such/ceedling' )).not_to eq( described_class.new( '/no/such/other' ) )
+    end
+
+    it 'ignores case on Windows only' do
+      a = described_class.new( '/no/such/Ceedling' )
+      b = described_class.new( '/no/such/ceedling' )
+
+      allow(described_class).to receive(:windows?).and_return( true )
+      expect(a).to eq( b )
+
+      allow(described_class).to receive(:windows?).and_return( false )
+      expect(a).not_to eq( b )
+    end
+
+    it 'is never equal to something other than an Installation' do
+      expect(described_class.new( '/no/such/ceedling' )).not_to eq( '/no/such/ceedling' )
+    end
+  end
+
+  # GH #1365: copies vendored by 1.1.0 through 1.2.1 lack the built-in mixins their own launcher validates
+  describe '#missing_builtin_mixins?' do
+    def write_mixins_rb(root, text)
+      FileUtils.mkdir_p( File.join( root, 'bin' ) )
+      File.write( File.join( root, 'bin', 'mixins.rb' ), text )
+    end
+
+    BUILTIN = "BUILTIN_MIXIN_LOAD_PATHS = [ File.join( _vendor, UNITY_ROOT_PATH, 'test', 'targets' ) ].freeze\n"
+
+    it 'is true when the launcher validates built-in mixins the installation does not hold' do
+      Dir.mktmpdir do |root|
+        write_mixins_rb( root, BUILTIN )
+
+        expect(described_class.new( root ).missing_builtin_mixins?).to be( true )
+      end
+    end
+
+    it 'is false when the installation holds its built-in mixins' do
+      Dir.mktmpdir do |root|
+        write_mixins_rb( root, BUILTIN )
+        FileUtils.mkdir_p( File.join( root, 'vendor', 'unity', 'test', 'targets' ) )
+
+        expect(described_class.new( root ).missing_builtin_mixins?).to be( false )
+      end
+    end
+
+    it 'is false for a launcher with no built-in mixins, as before 1.1.0' do
+      Dir.mktmpdir do |root|
+        write_mixins_rb( root, "BUILTIN_MIXINS = {}\n" )
+
+        expect(described_class.new( root ).missing_builtin_mixins?).to be( false )
+      end
+    end
+
+    it 'is false for an installation with no bin/mixins.rb' do
+      Dir.mktmpdir do |root|
+        expect(described_class.new( root ).missing_builtin_mixins?).to be( false )
+      end
+    end
+  end
+
+  describe '#name' do
+    it 'is the noun and version, or the noun alone when the version cannot be read' do
+      Dir.mktmpdir do |root|
+        expect(described_class.new( root ).name).to eq( 'Ceedling' )
+
+        write_version( root, VERSION_1_1 )
+        expect(described_class.new( root ).name).to eq( 'Ceedling 1.1.10' )
+        expect(described_class.new( root ).name( 'Ceedling launcher' )).to eq( 'Ceedling launcher 1.1.10' )
+      end
+    end
+  end
+
+  describe '#describe' do
+    it 'names the version and root' do
+      Dir.mktmpdir do |root|
+        write_version( root, VERSION_1_1 )
+
+        expect(described_class.new( root ).describe).to eq( "Ceedling 1.1.10 at #{File.expand_path( root )}/" )
+      end
+    end
+
+    it 'leaves out a version it cannot read' do
+      Dir.mktmpdir do |root|
+        expect(described_class.new( root ).describe).to eq( "Ceedling at #{File.expand_path( root )}/" )
+      end
+    end
+
+    it 'takes a different leading noun' do
+      Dir.mktmpdir do |root|
+        expect(described_class.new( root ).describe( 'Ceedling launcher' )).to eq( "Ceedling launcher at #{File.expand_path( root )}/" )
+      end
+    end
+  end
+end

data/spec/units/library_resolver_spec.rb

@@ -0,0 +1,157 @@
+# =========================================================================
+#   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/file_wrapper'
+require 'ceedling/filesystem/file_path_collection_utils'
+require 'ceedling/filename_extension'
+require 'ceedling/library_resolver'
+require 'ceedling/defaults'
+
+# GH #1368: a link tracked its libraries only by their -l and -L arguments, so a library
+# rebuilt under the same name relinked nothing. The resolver finds the files they name.
+describe LibraryResolver do
+  around(:each) do |example|
+    Dir.mktmpdir do |dir|
+      Dir.chdir( dir ) { example.run }
+    end
+  end
+
+  before(:each) do
+    stub_const( 'EXTENSION_LIBRARIES', FilenameExtension.new( ['.a', '.so'] ) )
+
+    file_wrapper = FileWrapper.new( {:loginator => double('loginator').as_null_object, :verbosinator => double('verbosinator').as_null_object} )
+    @resolver = described_class.new( {
+      :file_wrapper               => file_wrapper,
+      :file_path_collection_utils => FilePathCollectionUtils.new( {:file_wrapper => file_wrapper} )
+    } )
+  end
+
+  def make(*files)
+    files.each { |file| FileUtils.mkdir_p( File.dirname( file ) ); File.write( file, '' ) }
+  end
+
+  def resolve(entries, search_paths: ['vendor/lib'], files: [])
+    @resolver.resolve( entries: entries, search_paths: search_paths, files: files )
+  end
+
+  it 'finds a bare name as a static or a shared library on the search paths' do
+    make( 'vendor/lib/libx.a', 'vendor/lib/liby.so' )
+
+    expect( resolve( ['x', 'y'] ) ).to eq( ['vendor/lib/libx.a', 'vendor/lib/liby.so'] )
+  end
+
+  it 'finds a bare name with the extensions toolchains add, and without the lib prefix' do
+    make( 'vendor/lib/libmac.dylib', 'vendor/lib/libmingw.dll.a', 'vendor/lib/msvc.lib' )
+
+    expect( resolve( ['mac', 'mingw', 'msvc'] ) ).to eq( ['vendor/lib/libmac.dylib', 'vendor/lib/libmingw.dll.a', 'vendor/lib/msvc.lib'] )
+  end
+
+  it 'finds the exact filename an `-l:` entry names' do
+    make( 'vendor/lib/libexact.so.1' )
+
+    expect( resolve( [':libexact.so.1'] ) ).to eq( ['vendor/lib/libexact.so.1'] )
+  end
+
+  it 'finds a path as given, or on the search paths' do
+    make( 'prebuilt/libp.a', 'vendor/lib/sub/libq.a' )
+
+    expect( resolve( ['prebuilt/libp.a', 'sub/libq.a'] ) ).to eq( ['prebuilt/libp.a', 'vendor/lib/sub/libq.a'] )
+  end
+
+  it 'finds an absolute path as given' do
+    make( 'abs/libz.a' )
+    absolute = File.expand_path( 'abs/libz.a' )
+
+    expect( resolve( [absolute] ) ).to eq( ['abs/libz.a'] )
+  end
+
+  it 'finds a name in every search path that holds it, since which one links is the toolchain\'s choice' do
+    make( 'one/libdup.a', 'two/libdup.a' )
+
+    expect( resolve( ['dup'], search_paths: ['one', 'two'] ) ).to eq( ['one/libdup.a', 'two/libdup.a'] )
+  end
+
+  it 'expands decorated and globbed search paths' do
+    make( 'deps/a/liba.a', 'deps/b/libb.a', 'deps/skip/libs.a' )
+
+    expect( resolve( ['a', 'b', 's'], search_paths: ['+:deps/**', '-:deps/skip'] ) ).to eq( ['deps/a/liba.a', 'deps/b/libb.a'] )
+  end
+
+  it 'finds nothing for a library only the toolchain\'s own search paths hold, so it never reads as changed' do
+    expect( resolve( ['m', 'missing.a', ':libnone.so'] ) ).to eq( [] )
+  end
+
+  it 'adds the existing files given directly, once each' do
+    make( 'vendor/lib/libx.a', 'build/deps/libfusion.so.1' )
+
+    expect( resolve( ['x'], files: ['build/deps/libfusion.so.1', 'build/deps/absent.a', 'vendor/lib/libx.a'] ) ).to eq(
+      ['vendor/lib/libx.a', 'build/deps/libfusion.so.1']
+    )
+  end
+
+  describe '#link_files' do
+    it 'resolves entries on the configured library paths, with the files plugins publish' do
+      make( 'vendor/lib/libx.a', 'build/deps/libfusion.so.1' )
+      stub_const( 'PATHS_LIBRARIES', ['vendor/lib'] )
+      stub_const( 'LIBRARIES_LINK_FILES', ['build/deps/libfusion.so.1'] )
+
+      expect( @resolver.link_files( ['x', 'm'] ) ).to eq( ['vendor/lib/libx.a', 'build/deps/libfusion.so.1'] )
+    end
+
+    it 'resolves nothing when neither library paths nor plugin files are configured' do
+      hide_const( 'PATHS_LIBRARIES' )
+      hide_const( 'LIBRARIES_LINK_FILES' )
+
+      expect( @resolver.link_files( ['x'] ) ).to eq( [] )
+    end
+  end
+
+  # The path handling audit around GH #1370: a library search path is configured like any
+  # other, with decorators and globs, and the linker reads neither
+  describe '#search_path_arguments' do
+    it 'gives the linker the directories a decorated, globbed library path names' do
+      FileUtils.mkdir_p( ['vendor/a', 'vendor/skip'] )
+      stub_const( 'PATHS_LIBRARIES', ['+:vendor/**', '-:vendor/skip'] )
+      stub_const( 'LIBRARIES_PATH_FLAG', '-L${1}' )
+
+      expect( @resolver.search_path_arguments ).to eq( ['-Lvendor', '-Lvendor/a'] )
+    end
+
+    # Quoted like every other default path argument, so a path with a space survives the shell
+    it 'quotes each directory under the default flag template' do
+      FileUtils.mkdir_p( 'vendor/third party/lib' )
+      stub_const( 'PATHS_LIBRARIES', ['vendor/third party/lib'] )
+      stub_const( 'LIBRARIES_PATH_FLAG', DEFAULT_CEEDLING_PROJECT_CONFIG[:libraries][:path_flag] )
+
+      expect( @resolver.search_path_arguments ).to eq( ['-L "vendor/third party/lib"'] )
+    end
+
+    # A plugin's library directories join :paths ↳ :libraries once configuration is done
+    it 'includes the directories a plugin adds to the library paths' do
+      FileUtils.mkdir_p( ['vendor/lib', 'build/deps'] )
+      stub_const( 'PATHS_LIBRARIES', ['vendor/lib'] )
+      stub_const( 'LIBRARIES_PATH_FLAG', '-L${1}' )
+      PATHS_LIBRARIES << 'build/deps'
+
+      expect( @resolver.search_path_arguments ).to eq( ['-Lvendor/lib', '-Lbuild/deps'] )
+    end
+
+    it 'gives no arguments without library paths' do
+      hide_const( 'PATHS_LIBRARIES' )
+
+      expect( @resolver.search_path_arguments ).to eq( [] )
+    end
+  end
+
+  it 'finds nothing without entries or search paths' do
+    expect( resolve( [], search_paths: [] ) ).to eq( [] )
+    expect( resolve( nil, search_paths: nil ) ).to eq( [] )
+  end
+end

data/spec/units/mock_locator_spec.rb

@@ -12,7 +12,7 @@ require 'ceedling/test_invoker/mock_locator'
 
 describe MockLocator do
   before(:each) do
-    @configurator       = double( "Configurator", cmock_mock_prefix: 'Mock' )
+    @configurator       = double( "Configurator", cmock_mock_prefix: 'Mock', cmock_mock_name_include_folder: true )
     @include_pathinator = double( "IncludePathinator" )
     @file_finder        = double( "FileFinder" )
     @file_path_utils    = double( "FilePathUtils" )
@@ -59,6 +59,21 @@ describe MockLocator do
       expect(@locator.directories( mocks, mocks_root: 'mocks', collection: [] )).to eq( ['mocks/drivers', 'mocks'] )
     end
 
+    # GH #1370's path handling audit: CMock's root plus a climbing folder must not leave the mock root
+    it "adds the root CMock climbs from for a mock whose #include folder climbs" do
+      allow(@file_finder).to receive(:resolve_mock).with( '../x/MockFoo.h', collection: [], complain: :error ).and_return( ['../x/foo.h', ''] )
+
+      expect(@locator.directories( [MockInclude.new( '../x/MockFoo.h' )], mocks_root: 'mocks', collection: [] ))
+        .to eq( ['mocks/_up_/x', 'mocks/_up_/_up_'] )
+    end
+
+    it "adds the directory a folder that ends the mirror leads down from" do
+      allow(@file_finder).to receive(:resolve_mock).with( 'uart/MockFoo.h', collection: [], complain: :error ).and_return( ['src/drivers/uart/foo.h', 'drivers/uart'] )
+
+      expect(@locator.directories( [MockInclude.new( 'uart/MockFoo.h' )], mocks_root: 'mocks', collection: [] ))
+        .to eq( ['mocks/drivers/uart', 'mocks/drivers'] )
+    end
+
     it "skips a Partial mock, which has no real header" do
       expect(@file_finder).to_not receive(:resolve_mock)
 
@@ -71,4 +86,64 @@ describe MockLocator do
       expect(@locator.directories( [MockInclude.new( 'MockGone.h' )], mocks_root: 'mocks', collection: [], complain: :ignore )).to eq( [] )
     end
   end
+  # CMock writes a mock below its root at the folder the #include names, and names the mock
+  # by that folder. The compiler reaches the mock through the #include as written, from
+  # the directory that folder leads down or climbs from (`reach`).
+  describe "#placement" do
+    def placement(include_path, subdir: 'drivers/uart')
+      @locator.placement( mocks_root: 'mocks/t', subdir: subdir, include_path: include_path )
+    end
+
+    it "keeps a bare #include's mock in its mirrored directory, with no folder" do
+      expect(placement( 'MockFoo.h' ).to_h).to eq( folder: nil, directory: 'mocks/t/drivers/uart', root: 'mocks/t/drivers/uart', reach: 'mocks/t/drivers/uart' )
+    end
+
+    it "roots CMock above a folder that ends the mirrored directory" do
+      expect(placement( 'uart/MockFoo.h' ).to_h).to eq( folder: 'uart', directory: 'mocks/t/drivers/uart', root: 'mocks/t/drivers', reach: 'mocks/t/drivers' )
+      expect(placement( 'drivers/uart/MockFoo.h' ).to_h).to eq( folder: 'drivers/uart', directory: 'mocks/t/drivers/uart', root: 'mocks/t', reach: 'mocks/t' )
+    end
+
+    # The mock root carries the test's name, which a folder must never be mistaken for ending
+    it "compares the folder with the header's mirrored subdirectory alone, not the mock root" do
+      spot = @locator.placement( mocks_root: 'mocks/test/test_c', subdir: '', include_path: 'test_c/MockFoo.h' )
+
+      expect(spot.to_h).to eq( folder: 'test_c', directory: 'mocks/test/test_c/test_c', root: 'mocks/test/test_c', reach: 'mocks/test/test_c' )
+    end
+
+    it "places the mock at the written path below the mock root for a folder longer than the mirror" do
+      expect(placement( 'more/sub/MockFoo.h', subdir: 'sub' ).to_h).to eq( folder: 'more/sub', directory: 'mocks/t/more/sub', root: 'mocks/t', reach: 'mocks/t' )
+    end
+
+    it "drops a leading ./ from the folder" do
+      expect(placement( './uart/MockFoo.h' ).folder).to eq( 'uart' )
+    end
+
+    it "passes no folder when :mock_name_include_folder is disabled, keeping the place the #include reaches" do
+      allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( false )
+
+      expect(placement( 'uart/MockFoo.h' ).to_h).to eq( folder: nil, directory: 'mocks/t/drivers/uart', root: 'mocks/t/drivers/uart', reach: 'mocks/t/drivers' )
+      expect(placement( 'more/sub/MockFoo.h', subdir: 'sub' ).to_h).to eq( folder: nil, directory: 'mocks/t/more/sub', root: 'mocks/t/more/sub', reach: 'mocks/t' )
+    end
+
+    it "keeps the mock of a folder that climbs below the mock root, reached from as deep as the climb" do
+      expect(placement( '../x/MockFoo.h', subdir: 'y' ).to_h).to eq( folder: '../x', directory: 'mocks/t/_up_/x', root: 'mocks/t/_up_/_up_', reach: 'mocks/t/_up_/_up_' )
+      expect(placement( '../../x/MockFoo.h', subdir: '' ).to_h)
+        .to eq( folder: '../../x', directory: 'mocks/t/_up_/_up_/x', root: 'mocks/t/_up_/_up_/_up_/_up_', reach: 'mocks/t/_up_/_up_/_up_/_up_' )
+    end
+
+    it "always writes the mock where CMock's root and its folder lead, and where the #include reaches" do
+      [true, false].each do |name_by_folder|
+        allow(@configurator).to receive(:cmock_mock_name_include_folder).and_return( name_by_folder )
+
+        ['MockFoo.h', 'uart/MockFoo.h', 'more/sub/MockFoo.h', '../x/MockFoo.h', '../../a/b/MockFoo.h', './uart/MockFoo.h'].each do |include_path|
+          spot    = placement( include_path )
+          written = File.dirname( include_path )
+
+          expect(File.expand_path( File.join( *[spot.root, spot.folder].compact ), '/w' )).to eq( File.expand_path( spot.directory, '/w' ) ), include_path
+          expect(File.expand_path( File.join( spot.reach, written ), '/w' )).to eq( File.expand_path( spot.directory, '/w' ) ), include_path
+          [spot.directory, spot.root, spot.reach].each { |dir| expect(dir.split( '/' )).to_not include( '..' ), include_path }
+        end
+      end
+    end
+  end
 end

data/spec/units/partials/partializer_config_spec.rb

@@ -76,6 +76,13 @@ describe PartializerConfig do
         expect( result['drivers/uart/config'].module ).to eq( 'drivers/uart/config' )
       end
 
+      # GH #1370 audit: a `.` segment names nothing, so `./drivers/uart` is `drivers/uart`
+      it "keys the config on the directory without its `.` segments" do
+        result = @config.extract_configs('TEST_PARTIAL_PUBLIC_MODULE_AT(./drivers/./uart, config)')
+
+        expect( result.keys ).to eq( ['drivers/uart/config'] )
+      end
+
       it "keeps two modules sharing a basename distinct" do
         result = @config.extract_configs(
           "TEST_PARTIAL_ALL_MODULE_AT(drivers/uart, config)\n" \

data/spec/units/partials/partializer_spec.rb

@@ -31,6 +31,7 @@ describe Partializer do
     allow(@configurator).to receive(:paths_test).and_return( ['test'] )
     allow(@configurator).to receive(:paths_support).and_return( [] )
     allow(@configurator).to receive(:paths_include).and_return( ['include'] )
+    allow(@configurator).to receive(:collection_mirror_roots_headers).and_return( ['test', 'include'] )
 
     @partializer = described_class.new(
       {

data/spec/units/partials_manager_spec.rb

@@ -364,6 +364,23 @@ describe PartialsManager do
       expect( @testable.partials.mocks ).to eq( ['Foo'] )
     end
 
+    # Build threads finish in any order, and a test's link records its objects in order
+    it "keeps a test's Partial modules in configuration order, however the batch finishes" do
+      allow(@partializer).to receive(:extract_implementation_functions).and_return( [double("FunctionDefinition")] )
+      allow(@partializer).to receive(:extract_interface_functions).and_return( [double("FunctionDeclaration")] )
+      allow(@batchinator).to receive(:exec) do |workload:, things:, &block|
+        things.reverse_each { |thing| block.call( thing ) }
+      end
+      @testable.partials.configs = %w[Alpha Beta Gamma].to_h do |name|
+        [name, Partials::Config.new( module: name, header: @config.header, source: @config.source )]
+      end
+
+      @manager.stage_generate_partials( @state )
+
+      expect( @testable.partials.tests ).to eq( %w[Alpha Beta Gamma] )
+      expect( @testable.partials.mocks ).to eq( %w[Alpha Beta Gamma] )
+    end
+
     it "does not add to tests when no implementation is extracted" do
       allow(@partializer).to receive(:extract_implementation_functions).and_return( nil )
       allow(@partializer).to receive(:extract_interface_functions).and_return( [double("FunctionDeclaration")] )

data/spec/units/plugins/bullseye_spec.rb

@@ -831,7 +831,7 @@ describe Bullseye do
           ceedling:     services,
           configurator: configurator,
           test_invoker: test_invoker,
-          file_wrapper: double('file_wrapper', exist?: false)
+          file_wrapper: double('file_wrapper', exist?: false, mkdir: nil)
         }.merge(ivars)
       )
     end
@@ -861,7 +861,7 @@ describe Bullseye do
         bullseye = build_process_bullseye({ bullseye_untested_sources: BULLSEYE_UNTESTED_SOURCES_LIST })
 
         expect(loginator).to receive(:log_list)
-          .with(['src/a.c', 'src/b.c'], kind_of(String), Verbosity::COMPLAIN, LogLabels::WARNING)
+          .with(['src/a.c', 'src/b.c'], kind_of(String), Verbosity::COMPLAIN)
         expect(generator).to_not receive(:generate_object_file_c)
 
         bullseye.process_untested_sources(sources: ['src/b.c', 'src/a.c'])
@@ -883,6 +883,19 @@ describe Bullseye do
         bullseye.process_untested_sources(sources: [])
       end
 
+      # An untested source's object sits at its path below the output root, in a
+      # directory no test build made
+      it 'makes the object\'s and dependencies file\'s directories before compiling' do
+        allow(dependinator).to receive(:stale?).and_return(true)
+        untested_wrapper = double('file_wrapper', exist?: false)
+        bullseye = build_process_bullseye({ bullseye_untested_sources: BULLSEYE_UNTESTED_SOURCES_COMPILE }, file_wrapper: untested_wrapper)
+
+        expect(untested_wrapper).to receive(:mkdir).with('build/bullseye/out/src').twice.ordered
+        expect(generator).to receive(:generate_object_file_c).ordered
+
+        bullseye.process_untested_sources(sources: ['src/a.c'])
+      end
+
       it 'skips compilation for an already-fresh object' do
         allow(dependinator).to receive(:stale?).and_return(false)
         bullseye = build_process_bullseye({ bullseye_untested_sources: BULLSEYE_UNTESTED_SOURCES_COMPILE })

data/spec/units/plugins/console_reportinator_spec.rb

@@ -9,8 +9,8 @@ require 'spec_helper'
 require 'ceedling/tool_executor'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
-require 'ceedling/path_mirror'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/path_mirror'
+require 'ceedling/filesystem/file_path_utils'
 
 PROJECT_BUILD_ROOT           = 'build'     unless defined?(PROJECT_BUILD_ROOT)
 PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
@@ -30,12 +30,18 @@ describe ConsoleReportinator do
   let(:test_invoker)        { double('test_invoker') }
   let(:tool_executor)       { double('tool_executor') }
   let(:configurator) do
-    double('configurator', paths_source: ['src'], paths_support: ['support'], cmock_mock_prefix: 'mock_')
+    double(
+      'configurator',
+      paths_source: ['src'], paths_support: ['support'], cmock_mock_prefix: 'mock_',
+      project_build_root: 'build', extension_object: FilenameExtension.new('.o'),
+      project_use_partials: true, project_use_mocks: true,
+      project_test_partials_path: 'build/test/partials', cmock_mock_path: 'build/test/mocks'
+    )
   end
-  # Real, so reversing a generated Partial filename here exercises the same code that
-  # builds those filenames rather than a restatement of it. Touches no filesystem.
+  # Real, so reversing a generated Partial filename, or placing an object, exercises the
+  # same code the build uses rather than a restatement of it. Touches no filesystem.
   let(:file_path_utils) do
-    FilePathUtils.new({ configurator: configurator, file_wrapper: double('file_wrapper') })
+    FilePathUtils.new({ configurator: configurator, file_wrapper: double('file_wrapper', check_path_length: nil) })
   end
   let(:system_objects) do
     {
@@ -195,33 +201,28 @@ describe ConsoleReportinator do
       reportinator.send(:run_gcov_summary, 'test_foo', 'src/foo.c', {})
     end
 
-    it 'searches a nested source\'s mirrored subdirectory, not the flat test-output root' do
-      allow(configurator).to receive(:paths_source).and_return(['src'])
-      allow(configurator).to receive(:paths_support).and_return([])
+    # The test's build placed the object, and its coverage data, at the source's path from
+    # the project root
+    it 'searches the directory its test\'s build placed the source\'s object in' do
       stub_exec(exit_code: 0, output: 'coverage text')
       expect(tool_executor).to receive(:build_command_line)
-        .with(TOOLS_GCOV_SUMMARY, [], 'foo.c', File.join('build/gcov/out/test_foo', 'nested'))
+        .with(TOOLS_GCOV_SUMMARY, [], 'foo.c', 'build/gcov/out/test_foo/src/nested')
         .and_return({ options: {} })
       reportinator.send(:run_gcov_summary, 'test_foo', 'src/nested/foo.c', {})
     end
 
-    it 'searches the flat test-output root for a source directly under a configured path' do
-      allow(configurator).to receive(:paths_source).and_return(['src'])
-      allow(configurator).to receive(:paths_support).and_return([])
+    it 'searches the test-output root for a source at the project root' do
       stub_exec(exit_code: 0, output: 'coverage text')
       expect(tool_executor).to receive(:build_command_line)
         .with(TOOLS_GCOV_SUMMARY, [], 'foo.c', 'build/gcov/out/test_foo')
         .and_return({ options: {} })
-      reportinator.send(:run_gcov_summary, 'test_foo', 'src/foo.c', {})
+      reportinator.send(:run_gcov_summary, 'test_foo', 'foo.c', {})
     end
 
     # A generated Partial sits below its own test's Partials build root, not a configured
     # source root, so measuring against the source roots yields no subdirectory at all and
     # gcov is pointed at the flat root while the coverage data sits one level down.
     it 'searches a generated Partial\'s own mirrored subdirectory' do
-      allow(configurator).to receive(:paths_source).and_return(['src'])
-      allow(configurator).to receive(:paths_support).and_return([])
-      allow(configurator).to receive(:project_test_partials_path).and_return('build/test/partials')
       stub_exec(exit_code: 0, output: 'coverage text')
 
       expect(tool_executor).to receive(:build_command_line)
@@ -238,9 +239,6 @@ describe ConsoleReportinator do
     end
 
     it 'searches the flat root for a Partial of a module named without a directory' do
-      allow(configurator).to receive(:paths_source).and_return(['src'])
-      allow(configurator).to receive(:paths_support).and_return([])
-      allow(configurator).to receive(:project_test_partials_path).and_return('build/test/partials')
       stub_exec(exit_code: 0, output: 'coverage text')
 
       expect(tool_executor).to receive(:build_command_line)