ceedling 1.1.9 → 1.2.0

data/spec/units/release_build_planner_spec.rb

@@ -0,0 +1,144 @@
+# =========================================================================
+#   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 'ceedling/release_invoker/release_build_planner'
+
+describe ReleaseBuildPlanner do
+  before(:each) do
+    @configurator     = double( "Configurator" )
+    @loginator        = double( "Loginator" )
+    @reportinator     = double( "Reportinator" )
+    @flaginator       = double( "Flaginator" )
+    @defineinator     = double( "Defineinator" )
+    @file_path_utils  = double( "FilePathUtils" )
+    @file_wrapper     = double( "FileWrapper" )
+
+    @planner = described_class.new(
+      {
+        :configurator    => @configurator,
+        :loginator       => @loginator,
+        :reportinator    => @reportinator,
+        :flaginator      => @flaginator,
+        :defineinator    => @defineinator,
+        :file_path_utils => @file_path_utils,
+        :file_wrapper    => @file_wrapper
+      }
+    )
+
+    @state = ReleaseInvokerTypes::ReleaseState.new()
+
+    allow(@configurator).to receive(:tools_release_compiler).and_return( { executable: 'gcc', arguments: [] } )
+    allow(@configurator).to receive(:tools_release_linker).and_return( { executable: 'gcc', arguments: [] } )
+    allow(@configurator).to receive(:project_release_build_target).and_return( 'build/release/out/project.out' )
+    allow(@configurator).to receive(:collection_release_build_input).and_return( ['src/Foo.c'] )
+    allow(@configurator).to receive(:collection_release_artifact_extra_link_objects).and_return( [] )
+    allow(@configurator).to receive(:collection_paths_include).and_return( ['src'] )
+
+    allow(@flaginator).to receive(:flag_down).and_return( [] )
+    allow(@defineinator).to receive(:defines).and_return( [] )
+    allow(@file_path_utils).to receive(:form_release_build_objects_filelist) { |files| files.map { |f| "build/release/out/#{File.basename(f, '.*')}.o" } }
+  end
+
+  describe "#plan" do
+    it "computes the object list from the full release source collection when files is nil" do
+      @planner.plan( @state, files: nil )
+      expect( @state.objects ).to eq( ['build/release/out/Foo.o'] )
+    end
+
+    it "includes extra link-only objects alongside the compiled sources" do
+      allow(@configurator).to receive(:collection_release_artifact_extra_link_objects).and_return( ['vendor/cexception/CException.o'] )
+      expect(@file_path_utils).to receive(:form_release_build_objects_filelist).with( ['src/Foo.c', 'vendor/cexception/CException.o'] ).and_return( [] )
+      @planner.plan( @state, files: nil )
+    end
+
+    it "scopes the object list to just the given file when files is provided, ignoring the full source collection" do
+      expect(@file_path_utils).to receive(:form_release_build_objects_filelist).with( ['src/Bar.c'] ).and_return( ['build/release/out/Bar.o'] )
+      @planner.plan( @state, files: ['src/Bar.c'] )
+      expect( @state.objects ).to eq( ['build/release/out/Bar.o'] )
+    end
+
+    it "resolves compile, assemble, and link flags once for the whole build, with no per-file matcher" do
+      expect(@flaginator).to receive(:flag_down).with( context: RELEASE_SYM, operation: OPERATION_COMPILE_SYM ).and_return( ['-Wall'] )
+      expect(@flaginator).to receive(:flag_down).with( context: RELEASE_SYM, operation: OPERATION_ASSEMBLE_SYM ).and_return( ['-mthumb'] )
+      expect(@flaginator).to receive(:flag_down).with( context: RELEASE_SYM, operation: OPERATION_LINK_SYM ).and_return( ['-static'] )
+
+      @planner.plan( @state, files: nil )
+
+      expect( @state.compile_flags ).to eq( ['-Wall'] )
+      expect( @state.assemble_flags ).to eq( ['-mthumb'] )
+      expect( @state.link_flags ).to eq( ['-static'] )
+    end
+
+    it "resolves defines once for the whole build" do
+      expect(@defineinator).to receive(:defines).with( subkey: RELEASE_SYM ).and_return( ['FEATURE_X=ON'] )
+      @planner.plan( @state, files: nil )
+      expect( @state.defines ).to eq( ['FEATURE_X=ON'] )
+    end
+
+    it "resolves search paths from the project's include path collection" do
+      @planner.plan( @state, files: nil )
+      expect( @state.search_paths ).to eq( ['src'] )
+    end
+
+    context "tool tag tailoring" do
+      it "leaves tools untouched for a plain executable target" do
+        compiler = { executable: DEFAULT_RELEASE_COMPILER_TOOL[:executable], arguments: [] }
+        linker   = { executable: 'gcc', arguments: [] }
+        allow(@configurator).to receive(:tools_release_compiler).and_return( compiler )
+        allow(@configurator).to receive(:tools_release_linker).and_return( linker )
+        allow(@configurator).to receive(:project_release_build_target).and_return( 'build/release/out/project.out' )
+
+        @planner.plan( @state, files: nil )
+
+        expect( compiler[:arguments] ).to eq( [] )
+        expect( linker[:arguments] ).to eq( [] )
+        expect( linker[:executable] ).to eq( 'gcc' )
+      end
+
+      it "adds -fPIC and -shared for a .so target using the default compiler" do
+        compiler = { executable: DEFAULT_RELEASE_COMPILER_TOOL[:executable], arguments: [] }
+        linker   = { executable: 'gcc', arguments: [] }
+        allow(@configurator).to receive(:tools_release_compiler).and_return( compiler )
+        allow(@configurator).to receive(:tools_release_linker).and_return( linker )
+        allow(@configurator).to receive(:project_release_build_target).and_return( 'build/release/out/project.so' )
+
+        @planner.plan( @state, files: nil )
+
+        expect( compiler[:arguments] ).to include( '-fPIC' )
+        expect( linker[:arguments] ).to include( '-shared' )
+      end
+
+      it "swaps the linker for ar and adds -fPIC for a .a target using the default compiler" do
+        compiler = { executable: DEFAULT_RELEASE_COMPILER_TOOL[:executable], arguments: [] }
+        linker   = { executable: 'gcc', arguments: [] }
+        allow(@configurator).to receive(:tools_release_compiler).and_return( compiler )
+        allow(@configurator).to receive(:tools_release_linker).and_return( linker )
+        allow(@configurator).to receive(:project_release_build_target).and_return( 'build/release/out/project.a' )
+
+        @planner.plan( @state, files: nil )
+
+        expect( compiler[:arguments] ).to include( '-fPIC' )
+        expect( linker[:executable] ).to eq( 'ar' )
+        expect( linker[:arguments] ).to eq( ['rcs', '${2}', '${1}'] )
+      end
+
+      it "does nothing when the project has configured its own compiler tool (not the Ceedling default)" do
+        compiler = { executable: 'my-custom-gcc', arguments: [] }
+        linker   = { executable: 'gcc', arguments: [] }
+        allow(@configurator).to receive(:tools_release_compiler).and_return( compiler )
+        allow(@configurator).to receive(:tools_release_linker).and_return( linker )
+        allow(@configurator).to receive(:project_release_build_target).and_return( 'build/release/out/project.so' )
+
+        @planner.plan( @state, files: nil )
+
+        expect( compiler[:arguments] ).to eq( [] )
+        expect( linker[:arguments] ).to eq( [] )
+      end
+    end
+  end
+end

data/spec/units/release_invoker_spec.rb

@@ -0,0 +1,127 @@
+# =========================================================================
+#   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 'ceedling/release_invoker/release_invoker'
+require 'ceedling/exceptions'
+require 'ceedling/system_wrapper'
+
+describe ReleaseInvoker do
+  before(:each) do
+    @application            = double( "Application" )
+    @plugin_manager         = double( "PluginManager" )
+    @dependinator           = double( "Dependinator" )
+    @loginator              = double( "Loginator" )
+    @batchinator             = double( "Batchinator" )
+    @release_build_planner  = double( "ReleaseBuildPlanner" )
+    @release_build_executor = double( "ReleaseBuildExecutor" )
+
+    allow(@plugin_manager).to receive(:pre_release_build)
+    allow(@plugin_manager).to receive(:post_release_build)
+    allow(@dependinator).to receive(:open)
+    allow(@dependinator).to receive(:flush)
+    allow(@release_build_planner).to receive(:plan)
+    allow(@release_build_executor).to receive(:compile_objects)
+    allow(@release_build_executor).to receive(:link)
+    allow(@release_build_executor).to receive(:artifactinate)
+    allow(@batchinator).to receive(:build_step) { |*_args, &block| block.call }
+
+    @invoker = described_class.new(
+      {
+        :application             => @application,
+        :plugin_manager          => @plugin_manager,
+        :dependinator            => @dependinator,
+        :loginator               => @loginator,
+        :batchinator             => @batchinator,
+        :release_build_planner   => @release_build_planner,
+        :release_build_executor  => @release_build_executor
+      }
+    )
+  end
+
+  describe "#setup_and_invoke" do
+    it "builds a fresh release state and plans against it, passing files through" do
+      expect(@release_build_planner).to receive(:plan) do |state, files:|
+        expect( state ).to be_a( ReleaseInvokerTypes::ReleaseState )
+        expect( files ).to eq( ['src/Foo.c'] )
+      end
+
+      @invoker.setup_and_invoke( files: ['src/Foo.c'] )
+    end
+
+    it "defaults files to nil for a full build" do
+      expect(@release_build_planner).to receive(:plan) do |_state, files:|
+        expect( files ).to be_nil
+      end
+
+      @invoker.setup_and_invoke()
+    end
+
+    it "compiles objects, links, and collects artifacts, in that order, for a full build" do
+      expect(@release_build_planner).to receive(:plan).ordered
+      expect(@release_build_executor).to receive(:compile_objects).ordered
+      expect(@release_build_executor).to receive(:link).ordered
+      expect(@release_build_executor).to receive(:artifactinate).ordered
+
+      @invoker.setup_and_invoke()
+    end
+
+    it "stops after compiling objects and never links or collects artifacts when files is given" do
+      expect(@release_build_executor).to receive(:compile_objects)
+      expect(@release_build_executor).to_not receive(:link)
+      expect(@release_build_executor).to_not receive(:artifactinate)
+
+      @invoker.setup_and_invoke( files: ['src/Foo.c'] )
+    end
+
+    it "opens the dependency cache under the :release identifier, and fires the pre/post release-build plugin hooks, around the run" do
+      expect(@plugin_manager).to receive(:pre_release_build).ordered
+      expect(@dependinator).to receive(:open).with( identifier: :release ).ordered
+      expect(@release_build_planner).to receive(:plan).ordered
+      expect(@release_build_executor).to receive(:compile_objects).ordered
+      expect(@release_build_executor).to receive(:link).ordered
+      expect(@release_build_executor).to receive(:artifactinate).ordered
+      expect(@dependinator).to receive(:flush).ordered
+      expect(@plugin_manager).to receive(:post_release_build).ordered
+
+      @invoker.setup_and_invoke()
+    end
+
+    it "flushes with refresh_dependencies true for a full build" do
+      expect(@dependinator).to receive(:flush).with( refresh_dependencies: true )
+      @invoker.setup_and_invoke()
+    end
+
+    it "flushes with refresh_dependencies false for a files-scoped build, so untouched release targets survive" do
+      expect(@dependinator).to receive(:flush).with( refresh_dependencies: false )
+      @invoker.setup_and_invoke( files: ['src/Foo.c'] )
+    end
+
+    it "catches an exception raised while building, logs it, and registers a build failure rather than propagating it" do
+      allow(@release_build_executor).to receive(:compile_objects).and_raise( CeedlingException.new("compile failed") )
+      allow(@loginator).to receive(:log)
+      allow(@loginator).to receive(:log_debug_backtrace)
+
+      expect(@application).to receive(:register_build_failure)
+      expect(@loginator).to receive(:log).with( "compile failed", Verbosity::ERRORS, LogLabels::EXCEPTION )
+
+      expect { @invoker.setup_and_invoke() }.to_not raise_error
+    end
+
+    it "still flushes the dependency cache and fires the post-build hook after a caught exception" do
+      allow(@release_build_executor).to receive(:compile_objects).and_raise( CeedlingException.new("boom") )
+      allow(@application).to receive(:register_build_failure)
+      allow(@loginator).to receive(:log)
+      allow(@loginator).to receive(:log_debug_backtrace)
+
+      expect(@dependinator).to receive(:flush)
+      expect(@plugin_manager).to receive(:post_release_build)
+
+      @invoker.setup_and_invoke()
+    end
+  end
+end

data/spec/units/reportinator_spec.rb

@@ -224,6 +224,41 @@ describe Reportinator do
       result = @rp.generate_module_progress(module_name: 'bar', filename: 'baz.c', operation: 'Compiling')
       expect(result).to eq("Compiling bar::baz.c...")
     end
+
+    it 'omits module label when filename matches only the last segment of a mirrored, multi-segment module name' do
+      result = @rp.generate_module_progress(module_name: 'adc/TestFoo', filename: 'TestFoo.c', operation: 'Compiling')
+      expect(result).to eq("Compiling TestFoo.c...")
+    end
+
+    it 'prepends the full mirrored module name when filename differs from its last segment' do
+      result = @rp.generate_module_progress(module_name: 'adc/TestFoo', filename: 'MockBar.c', operation: 'Generating mock for')
+      expect(result).to eq("Generating mock for adc/TestFoo::MockBar.c...")
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # #generate_skip_summary
+  # ---------------------------------------------------------------------------
+
+  describe '#generate_skip_summary' do
+    it 'states the count and default reason, pluralizing the noun' do
+      result = @rp.generate_skip_summary(task: 'compilation', count: 4, noun: 'objects')
+      expect(result).to eq("Skipping compilation for 4 objects (nothing changed)...")
+    end
+
+    it 'singularizes the noun when the count is 1' do
+      result = @rp.generate_skip_summary(task: 'compilation', count: 1, noun: 'objects')
+      expect(result).to eq("Skipping compilation for 1 object (nothing changed)...")
+    end
+
+    it 'uses a custom reason when given' do
+      result = @rp.generate_skip_summary(task: 'test execution', count: 3, noun: 'tests', reason: 'reusing cached results')
+      expect(result).to eq("Skipping test execution for 3 tests (reusing cached results)...")
+    end
+
+    it 'returns nil when nothing was skipped' do
+      expect(@rp.generate_skip_summary(task: 'compilation', count: 0, noun: 'objects')).to be_nil
+    end
   end
 
   # ---------------------------------------------------------------------------

data/spec/units/ruby_expandinator_spec.rb

@@ -35,6 +35,42 @@ describe RubyExpandinator do
       @ruby_expandinator.enable!
       expect(@ruby_expandinator.expand('#{1+1}', source: 'x')).to eq('2')
     end
+
+    # Only #{...} segments are Ruby. Everything around them is configuration text kept as written.
+    context 'with the feature enabled' do
+      before(:each) { @ruby_expandinator.enable! }
+
+      it 'keeps backslashes outside a segment literal' do
+        expect(@ruby_expandinator.expand('C:\foo\new #{1+1}', source: 'x')).to eq('C:\foo\new 2')
+      end
+
+      it 'keeps quote and comment characters outside a segment literal' do
+        expect(@ruby_expandinator.expand('-:"#{1+1}/a.c" # note', source: 'x')).to eq('-:"2/a.c" # note')
+      end
+
+      it 'keeps an escaped segment as literal text' do
+        expect(@ruby_expandinator.expand('a\#{1}b #{2}', source: 'x')).to eq('a#{1}b 2')
+      end
+
+      it 'expands every segment in a string' do
+        expect(@ruby_expandinator.expand('#{1}-#{2}-#{3}', source: 'x')).to eq('1-2-3')
+      end
+
+      it 'expands a segment holding a block and its braces' do
+        expect(@ruby_expandinator.expand('#{[1, 2].map { |n| n * 2 }.join}/x', source: 'x')).to eq('24/x')
+      end
+
+      it 'expands a segment holding a quoted brace' do
+        expect(@ruby_expandinator.expand('#{"}" + "{"}', source: 'x')).to eq('}{')
+      end
+
+      # A brace inside a quote cannot close the segment, so this segment never closes
+      it 'raises naming the source for a segment that never closes' do
+        expect {
+          @ruby_expandinator.expand('a/#{"}"/b', source: ':paths ↳ :source')
+        }.to raise_error(CeedlingException, /:paths ↳ :source/)
+      end
+    end
   end
 
   describe '#check!' do

data/spec/units/standin_headerinator_spec.rb

@@ -0,0 +1,168 @@
+# =========================================================================
+#   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 'ceedling/constants'
+require 'ceedling/includes/includes'
+require 'ceedling/test_invoker/test_invoker_types'
+require 'ceedling/test_invoker/standin_headerinator'
+
+describe StandinHeaderinator do
+  before(:each) do
+    @configurator    = double( "Configurator", cmock_mock_prefix: 'Mock', get_cmock_config: {} )
+    @loginator       = double( "Loginator" )
+    @reportinator    = double( "Reportinator" )
+    @file_wrapper    = double( "FileWrapper" )
+    @file_path_utils = double( "FilePathUtils" )
+    @mock_locator    = double( "MockLocator" )
+
+    allow(@reportinator).to receive(:generate_module_progress).and_return( '' )
+    allow(@loginator).to receive(:log)
+    allow(@file_wrapper).to receive(:exist?).and_return( false )
+    allow(@file_wrapper).to receive(:mkdir)
+    allow(@file_wrapper).to receive(:write_blank_file)
+    allow(@file_wrapper).to receive(:write)
+    allow(@file_path_utils).to receive(:form_mock_header_filepath) { |dir, name| File.join( 'build/test/mocks', dir, name ) }
+    allow(@file_path_utils).to receive(:form_partial_header_filepath) { |dir, name| File.join( 'build/test/partials', dir, name ) }
+    allow(@file_path_utils).to receive(:form_mock_output_path) do |root, subdir|
+      subdir.nil? || subdir.empty? ? root : File.join( root, subdir )
+    end
+    allow(@mock_locator).to receive(:header_collection).and_return( ['src/drivers/foo.h'] )
+    allow(@mock_locator).to receive(:locate).and_return( ['src/drivers/foo.h', 'drivers'] )
+
+    @standins = described_class.new(
+      configurator: @configurator, loginator: @loginator, reportinator: @reportinator,
+      file_wrapper: @file_wrapper, file_path_utils: @file_path_utils, mock_locator: @mock_locator
+    )
+
+    @testable = TestInvokerTypes::Testable.new(
+      name: 'a_test', filepath: 'test/TestFoo.c', paths: { mocks: 'build/test/mocks/a_test' },
+      search_paths: ['build/test/mocks/a_test', 'build/test/mocks/a_test/hw', 'src'],
+      mock_search_paths: ['build/test/mocks/a_test/hw']
+    )
+  end
+
+  describe "#place" do
+    # The real mock opens by including its header, so a macro that header defines is
+    # visible through the stand-in too
+    it "writes a mock's stand-in in its header's mirrored directory, including that header as the real mock will" do
+      expect(@file_wrapper).to receive(:mkdir).with( 'build/test/mocks/a_test/drivers' )
+      expect(@file_wrapper).to receive(:write)
+        .with( 'build/test/mocks/a_test/drivers/MockFoo.h', "#{StandinHeaderinator::MARKER}\n#include \"foo.h\"\n" )
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    it "includes the header in the project's CMock :orig_header_include_fmt" do
+      allow(@configurator).to receive(:get_cmock_config).and_return( { orig_header_include_fmt: '#include <%s>' } )
+
+      expect(@file_wrapper).to receive(:write).with( anything, "#{StandinHeaderinator::MARKER}\n#include <foo.h>\n" )
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    # A stand-in written by an earlier version, or for a different header, would hide the
+    # header's macros
+    it "rewrites an existing stand-in whose contents are out of date" do
+      allow(@file_wrapper).to receive(:exist?).and_return( true )
+      allow(@file_wrapper).to receive(:read).and_return( "// Ceedling intentionally blank file\n\n" )
+
+      expect(@file_wrapper).to receive(:write).with( 'build/test/mocks/a_test/drivers/MockFoo.h', anything )
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    it "reads only the start of an existing file to tell a stand-in from a real mock" do
+      allow(@file_wrapper).to receive(:exist?).and_return( true )
+      expect(@file_wrapper).to receive(:read).with( 'build/test/mocks/a_test/drivers/MockFoo.h', StandinHeaderinator::MARKER_READ_LENGTH )
+        .and_return( "/* AUTOGENERATED FILE. DO NOT EDIT. */\n" )
+      expect(@file_wrapper).to_not receive(:read).with( 'build/test/mocks/a_test/drivers/MockFoo.h' )
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    it "leaves an existing stand-in that is already current alone" do
+      allow(@file_wrapper).to receive(:exist?).and_return( true )
+      allow(@file_wrapper).to receive(:read).and_return( "#{StandinHeaderinator::MARKER}\n#include \"foo.h\"\n" )
+
+      expect(@file_wrapper).to_not receive(:write)
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    it "resolves a mock's header against the test's search paths without its mock directories" do
+      expect(@mock_locator).to receive(:header_collection)
+        .with( ['build/test/mocks/a_test', 'build/test/mocks/a_test/hw', 'src'], ['build/test/mocks/a_test/hw'] )
+        .and_return( ['src/drivers/foo.h'] )
+      expect(@mock_locator).to receive(:locate).with( Include.new( 'MockFoo.h' ), collection: ['src/drivers/foo.h'], complain: :error )
+        .and_return( ['src/drivers/foo.h', 'drivers'] )
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' )] )
+    end
+
+    it "gives the mirrored directories of the mocks it placed, once each" do
+      dirs = @standins.place( @testable, [Include.new( 'MockFoo.h' ), Include.new( 'MockBar.h' )] )
+
+      expect(dirs).to eq( ['build/test/mocks/a_test/drivers'] )
+    end
+
+    it "gives no directories when the test has no mock root" do
+      @testable.paths = {}
+
+      expect(@standins.place( @testable, [Include.new( 'MockFoo.h' )] )).to eq( [] )
+    end
+
+    it "places a Partial mock's stand-in by its own #include path, resolving no header" do
+      expect(@mock_locator).to_not receive(:locate)
+      expect(@file_wrapper).to receive(:write_blank_file)
+        .with( "build/test/mocks/a_test/Mock#{PARTIAL_FILENAME_PREFIX}foo_interface.h" )
+
+      expect(@standins.place( @testable, [Include.new( "Mock#{PARTIAL_FILENAME_PREFIX}foo_interface.h" )] )).to eq( [] )
+    end
+
+    it "places a Partial's stand-in beneath its test when its #include names no directory" do
+      expect(@file_wrapper).to receive(:mkdir).with( 'build/test/partials/a_test' )
+      expect(@file_wrapper).to receive(:write_blank_file)
+        .with( "build/test/partials/a_test/#{PARTIAL_FILENAME_PREFIX}config_impl.h" )
+
+      @standins.place( @testable, [Include.new( "#{PARTIAL_FILENAME_PREFIX}config_impl.h" )] )
+    end
+
+    it "places a Partial's stand-in under the directory its generated #include names" do
+      expect(@file_wrapper).to receive(:mkdir).with( 'build/test/partials/a_test/drivers/uart' )
+      expect(@file_wrapper).to receive(:write_blank_file)
+        .with( "build/test/partials/a_test/drivers/uart/#{PARTIAL_FILENAME_PREFIX}config_impl.h" )
+
+      @standins.place( @testable, [Include.new( "drivers/uart/#{PARTIAL_FILENAME_PREFIX}config_impl.h" )] )
+    end
+
+    # Mock generation tracks the file at a mock's path as an input, so rewriting it would
+    # invalidate the mock for nothing
+    it "leaves a real mock or Partial already at a stand-in's path alone" do
+      allow(@file_wrapper).to receive(:exist?).and_return( true )
+      allow(@file_wrapper).to receive(:read).and_return( "/* AUTOGENERATED FILE. DO NOT EDIT. */\n" )
+      expect(@file_wrapper).to_not receive(:write)
+      expect(@file_wrapper).to_not receive(:write_blank_file)
+      expect(@file_wrapper).to_not receive(:mkdir)
+
+      @standins.place( @testable, [Include.new( 'MockFoo.h' ), Include.new( "#{PARTIAL_FILENAME_PREFIX}config_impl.h" )] )
+    end
+
+    it "passes on how to treat a missing header, and places nothing for a mock without one" do
+      expect(@mock_locator).to receive(:locate).with( Include.new( 'MockGone.h' ), collection: anything, complain: :ignore ).and_return( [nil, nil] )
+      expect(@file_wrapper).to_not receive(:write)
+
+      expect(@standins.place( @testable, [Include.new( 'MockGone.h' )], complain: :ignore )).to eq( [] )
+    end
+
+    it "places nothing for an ordinary header" do
+      expect(@file_wrapper).to_not receive(:write_blank_file)
+
+      expect(@standins.place( @testable, [Include.new( 'foo.h' )] )).to eq( [] )
+    end
+  end
+end

data/spec/units/system_wrapper_spec.rb

@@ -22,6 +22,22 @@ describe SystemWrapper do
     "#{RbConfig.ruby} -e #{code.inspect}"
   end
 
+  # Portable across the whole CI platform matrix: asserts the regex classifies whatever
+  # host this test actually happens to run on, rather than hardcoding an expected result.
+  describe '.windows?' do
+    it 'matches the actual host_os of the machine running this test' do
+      expected = !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|msys|ucrt/i)
+      expect(SystemWrapper.windows?).to eq(expected)
+    end
+  end
+
+  describe '.macos?' do
+    it 'matches the actual host_os of the machine running this test' do
+      expected = !!(RbConfig::CONFIG['host_os'] =~ /darwin/i)
+      expect(SystemWrapper.macos?).to eq(expected)
+    end
+  end
+
   describe '#shell_capture3' do
     context 'boom: false (the default, and how test-fixture execution always runs)' do
       it 'forces exit_code to 0 even though the real subprocess exited nonzero' do