ceedling 1.1.2 → 1.1.4

data/spec/units/includes/includes_spec.rb

@@ -111,20 +111,38 @@ describe "Includes serialization" do
       expect(restored.map(&:filename)).to eq(["first.h", "second.h", "third.h", "fourth.h"])
     end
 
-    it "handles includes with paths during serialization" do
+    it "handles includes with an include_path override during serialization" do
       original = [
-        UserInclude.new("path/to/header.h", use_path: true),
-        SystemInclude.new("sys/stdio.h", use_path: true),
-        MockInclude.new("mocks/mock_module.h", use_path: true)
+        UserInclude.new("path/to/header.h", include_path: "path/to/header.h"),
+        SystemInclude.new("sys/stdio.h", include_path: "sys/stdio.h"),
+        MockInclude.new("mocks/mock_module.h")
       ]
-      
+
       hashes = Includes.to_hashes(original)
       restored = Includes.from_hashes(hashes)
-      
+
       expect(restored.length).to eq(3)
       expect(restored[0].filepath).to eq("path/to/header.h")
       expect(restored[1].filepath).to eq("sys/stdio.h")
       expect(restored[2].filepath).to eq("mocks/mock_module.h")
+      # `include_path` must itself round-trip, not merely `filepath` -- otherwise a cached
+      # build silently reverts to filename-only rendering on its next, cache-hit run.
+      expect("#{restored[0]}").to eq('#include "path/to/header.h"')
+      expect("#{restored[1]}").to eq('#include <sys/stdio.h>')
+    end
+
+    it "round-trips include_path, and has it take rendering precedence over filepath/filename" do
+      original = [
+        SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h", include_path: "sys/stat.h")
+      ]
+
+      hashes = Includes.to_hashes(original)
+      restored = Includes.from_hashes(hashes)
+
+      expect(restored.length).to eq(1)
+      expect(restored[0].filepath).to eq("/usr/include/x86_64-linux-gnu/sys/stat.h")
+      expect(restored[0].include_path).to eq("sys/stat.h")
+      expect("#{restored[0]}").to eq("#include <sys/stat.h>")
     end
 
     it "handles empty array" do
@@ -1054,16 +1072,88 @@ describe "Includes reconciliation" do
         Include.new("subdir/header.h"),
         Include.new("sys/types.h")
       ]
-      
+
       user = [UserInclude.new("header.h")]
       system = [SystemInclude.new("types.h")]
-      
+
       result = Includes.reconcile(bare: bare, user: user, system: system)
-      
+
       # Should match by filename only
       expect(result.length).to eq(2)
       expect(result[0].filename).to eq("types.h")
       expect(result[1].filename).to eq("header.h")
     end
+
+    it "preserves a system include directive's original directory components instead of collapsing to its bare filename" do
+      bare = [Include.new("sys/stat.h")]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect(result[0]).to be_a(SystemInclude)
+      expect(result[0].filepath).to eq("/usr/include/x86_64-linux-gnu/sys/stat.h")
+      expect("#{result[0]}").to eq("#include <sys/stat.h>")
+      expect(Includes.from_hashes(Includes.to_hashes(result)).map(&:to_s)).to eq(["#include <sys/stat.h>"])
+    end
+
+    it "prefers the more specific bare entry when a system header's basename collides with an unrelated bare entry" do
+      # A project's own quoted `#include "stat.h"` sitting alongside a system
+      # `#include <sys/stat.h>` in the same file: both reach `bare` as plain, untyped
+      # Include objects, and the short entry trivially "corresponds" to any longer
+      # resolved path ending in the same filename. The longer, genuinely-corresponding
+      # entry must still win, regardless of which one happens to appear first in `bare`.
+      bare = [
+        Include.new("stat.h"),
+        Include.new("sys/stat.h")
+      ]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect("#{result[0]}").to eq("#include <sys/stat.h>")
+    end
+
+    it "falls back to a same-filename bare entry when nothing corresponds by path" do
+      # The compiler's real search-path structure can diverge from a directive's own
+      # literal spelling (a symlinked or vendored include root, for instance), so a
+      # resolved system path may not share any trailing segment with its bare entry
+      # beyond the filename itself. Rendering the bare entry's own spelling is still
+      # strictly better than collapsing to the bare filename alone.
+      bare = [Include.new("compat/stat.h")]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/bits/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect("#{result[0]}").to eq("#include <compat/stat.h>")
+    end
+
+    it "does not hard-error over two same-named system headers, a normal toolchain wrapper-chain pattern rather than a project-file conflict" do
+      # e.g. a compiler-provided stdint.h #include_next-ing its libc counterpart --
+      # both real, both legitimately entered, both sharing a basename, neither a
+      # project file whose identity is actually in question.
+      bare = [Include.new("stdint.h")]
+
+      user = []
+      system = [
+        SystemInclude.new("/usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h"),
+        SystemInclude.new("/usr/include/stdint.h")
+      ]
+
+      result = nil
+      expect {
+        result = Includes.reconcile(bare: bare, user: user, system: system)
+      }.not_to raise_error
+
+      expect(result.length).to eq(2)
+      expect(result.map(&:filepath)).to include(
+        "/usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h", "/usr/include/stdint.h"
+      )
+    end
   end
-end    
+end

data/spec/units/partials/partializer_spec.rb

@@ -522,6 +522,31 @@ describe Partializer do
       expect(result).not_to include(UserInclude.new('partial1.h'))
       expect(result).not_to include(UserInclude.new('partial2.h'))
     end
+
+    it "appends the shared types header when one was generated for this module" do
+      includes = [UserInclude.new('header1.h')]
+      partials = {}
+      result = @partializer.remap_implementation_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials,
+        types_header: 'ceedling_partial_module_types.h'
+      )
+
+      expect(result).to include(UserInclude.new('ceedling_partial_module_types.h'))
+    end
+
+    it "does not append a types header when the module has none" do
+      includes = [UserInclude.new('header1.h')]
+      partials = {}
+      result = @partializer.remap_implementation_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials
+      )
+
+      expect(result).to match_array([UserInclude.new('header1.h')])
+    end
   end
 
   ###
@@ -683,6 +708,31 @@ describe Partializer do
       expect(result).not_to include(UserInclude.new('partial1.h'))
       expect(result).not_to include(UserInclude.new('partial2.h'))
     end
+
+    it "appends the shared types header when one was generated for this module" do
+      includes = [UserInclude.new('header1.h')]
+      partials = {}
+      result = @partializer.remap_interface_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials,
+        types_header: 'ceedling_partial_module_types.h'
+      )
+
+      expect(result).to include(UserInclude.new('ceedling_partial_module_types.h'))
+    end
+
+    it "does not append a types header when the module has none" do
+      includes = [UserInclude.new('header1.h')]
+      partials = {}
+      result = @partializer.remap_interface_header_includes(
+        name: 'module',
+        includes: includes,
+        partials: partials
+      )
+
+      expect(result).to match_array([UserInclude.new('header1.h')])
+    end
   end
 
   ###
@@ -1521,6 +1571,66 @@ describe Partializer do
       expect(result).to eq(filtered)
     end
 
+    it "merges declaration-only functions into the DEDUCT candidate pool" do
+      defn     = double('inline_func', name: 'inline_fn')
+      decl     = double('proto_func', name: 'proto_fn')
+      defs     = [defn]
+      decls    = [decl]
+      filtered = [double('iface_inline'), double('iface_proto')]
+      pf       = make_pf(type: Partials::DEDUCT)
+
+      expect(@partializer_helper).to receive(:filter_and_transform_funcs)
+        .with([defn, decl], Partials::DEDUCT, :interface).and_return(filtered)
+      allow(@partializer_helper).to receive(:subtract_funcs)
+        .with(funcs: filtered, names: []).and_return(filtered)
+
+      result = @partializer.extract_interface_functions(
+        test: 'test_mod', partial: 'mod',
+        definitions: defs, declarations: decls, config: make_config(mocks: pf)
+      )
+      expect(result).to eq(filtered)
+    end
+
+    it "merges declaration-only functions into the PUBLIC candidate pool too" do
+      defn     = double('def_func', name: 'pub_def')
+      decl     = double('decl_func', name: 'pub_decl')
+      defs     = [defn]
+      decls    = [decl]
+      filtered = [double('iface_func')]
+      pf       = make_pf(type: Partials::PUBLIC)
+
+      expect(@partializer_helper).to receive(:filter_and_transform_funcs)
+        .with([defn, decl], Partials::PUBLIC, :interface).and_return(filtered)
+      allow(@partializer_helper).to receive(:subtract_funcs)
+        .with(funcs: filtered, names: []).and_return(filtered)
+
+      result = @partializer.extract_interface_functions(
+        test: 'test_mod', partial: 'mod',
+        definitions: defs, declarations: decls, config: make_config(mocks: pf)
+      )
+      expect(result).to eq(filtered)
+    end
+
+    it "excludes a declaration already present as a definition with the same name (dedup)" do
+      defn     = double('def_func', name: 'shared')
+      decl     = double('decl_func', name: 'shared') # e.g. header prototype for the same function
+      defs     = [defn]
+      decls    = [decl]
+      filtered = [double('iface_func')]
+      pf       = make_pf(type: Partials::DEDUCT)
+
+      expect(@partializer_helper).to receive(:filter_and_transform_funcs)
+        .with([defn], Partials::DEDUCT, :interface).and_return(filtered)
+      allow(@partializer_helper).to receive(:subtract_funcs)
+        .with(funcs: filtered, names: []).and_return(filtered)
+
+      result = @partializer.extract_interface_functions(
+        test: 'test_mod', partial: 'mod',
+        definitions: defs, declarations: decls, config: make_config(mocks: pf)
+      )
+      expect(result).to eq(filtered)
+    end
+
     it "fills list from additions only for ACCUMULATE type" do
       defs   = [double('def', name: 'named')]
       decls  = []
@@ -1548,8 +1658,10 @@ describe Partializer do
       found = double('iface_func', name: 'decl_only')
       pf    = make_pf(type: Partials::ACCUMULATE, additions: ['decl_only'])
 
+      # candidates = definitions + declarations (ACCUMULATE ignores this list regardless --
+      # it always starts empty -- but it's still built before the type check discards it).
       allow(@partializer_helper).to receive(:filter_and_transform_funcs)
-        .with(defs, Partials::ACCUMULATE, :interface).and_return([])
+        .with(decls, Partials::ACCUMULATE, :interface).and_return([])
       expect(@partializer_helper).to receive(:find_and_transform_func)
         .with(name: 'decl_only', primary_funcs: defs, secondary_funcs: decls, output_type: :interface)
         .and_return(found)

data/spec/units/partials/partializer_utils_spec.rb

@@ -166,6 +166,17 @@ describe PartializerUtils do
         expect(result.signature).to eq(signature)
         expect(result).not_to respond_to(:code_block)
       end
+
+      it "strips a trailing semicolon from a declaration-sourced signature" do
+        # CFunctionDeclaration#signature_stripped always carries its own trailing
+        # semicolon (it's a bare prototype); CFunctionDefinition#signature_stripped never
+        # does. Callers render "#{signature};" uniformly, so this must not double up.
+        signature = 'void testFunc(int x);'
+
+        result = @utils.transform_function(mock_func, signature, :interface)
+
+        expect(result.signature).to eq('void testFunc(int x)')
+      end
     end
 
     context "when output_type is invalid" do

data/spec/units/preprocess/preprocessinator_includes_handler_spec.rb

@@ -19,16 +19,20 @@ RSpec.describe PreprocessinatorIncludesHandler do
   let(:real_parsing_parcels) { ParsingParcels.new }
 
   before :each do
-    @configurator    = double('configurator')
-    @include_factory = double('include_factory')
-    @file_wrapper    = double('file_wrapper')
-    @yaml_wrapper    = double('yaml_wrapper')
-    @loginator       = double('loginator')
-    @reportinator    = double('reportinator')
+    @configurator     = double('configurator')
+    @include_factory  = double('include_factory')
+    @file_wrapper     = double('file_wrapper')
+    @file_path_utils  = double('file_path_utils')
+    @tool_executor    = double('tool_executor')
+    @yaml_wrapper     = double('yaml_wrapper')
+    @loginator        = double('loginator')
+    @reportinator     = double('reportinator')
     @preprocessinator_line_marker_includes_extractor =
       double('preprocessinator_line_marker_includes_extractor')
 
     allow(@loginator).to receive(:log)
+    allow(@loginator).to receive(:lazy)
+    allow(@loginator).to receive(:log_list)
     allow(@reportinator).to receive(:generate_module_progress).and_return('')
 
     # Include factory helpers: return typed Include objects based on the path
@@ -50,8 +54,9 @@ RSpec.describe PreprocessinatorIncludesHandler do
         include_factory:        @include_factory,
         preprocessinator_line_marker_includes_extractor:
           @preprocessinator_line_marker_includes_extractor,
-        tool_executor:          double('tool_executor'),
+        tool_executor:          @tool_executor,
         file_wrapper:           @file_wrapper,
+        file_path_utils:        @file_path_utils,
         yaml_wrapper:           @yaml_wrapper,
         parsing_parcels:        real_parsing_parcels,
         loginator:              @loginator,
@@ -66,6 +71,90 @@ RSpec.describe PreprocessinatorIncludesHandler do
   end
 
 
+  # ===========================================================================
+  describe '#extract_bare_includes' do
+  # ===========================================================================
+  # Extraction stages an isolated, sibling-free copy of the file being scanned before running
+  # GCC's bare-includes preprocessor pass, so that GCC's own directory-relative #include
+  # resolution has no real sibling header available to find and recurse into.
+
+    let(:test_name)         { 'test_other' }
+    let(:filepath)          { '/project/test/test_other.c' }
+    let(:isolation_parent)  { '/project/build/test/preprocess/files/test_other' }
+    let(:isolation_dir)     { "#{isolation_parent}/tmp1234" }
+    let(:isolated_filepath) { "#{isolation_dir}/test_other.c" }
+    let(:make_rules) do
+      "test_other.o: #{isolated_filepath} unity.h mock_foo_func.h other.h\n\n" \
+      "unity.h:\n\nmock_foo_func.h:\n\nother.h:\n"
+    end
+
+    before :each do
+      allow(@file_path_utils).to receive(:form_test_preprocess_files_path)
+        .with(test_name).and_return(isolation_parent)
+      allow(@file_wrapper).to receive(:mkdir_tmp)
+        .with(nil, isolation_parent).and_return(isolation_dir)
+      allow(@file_wrapper).to receive(:cp).with(filepath, isolated_filepath)
+      allow(@file_wrapper).to receive(:rm_rf).with(isolation_dir)
+
+      allow(@configurator).to receive(:tools_test_bare_includes_preprocessor).and_return(:bare_tool)
+
+      allow(@tool_executor).to receive(:build_command_line) do |tool, extra_args, fp, defs, flgs, paths|
+        { options: {}, tool: tool, filepath: fp, defines: defs, flags: flgs, search_paths: paths }
+      end
+
+      allow(@tool_executor).to receive(:exec).and_return(output: make_rules)
+    end
+
+    def call_it
+      subject.extract_bare_includes(
+        test: test_name, filepath: filepath, search_paths: [], flags: [], defines: []
+      )
+    end
+
+    it 'stages a copy of the file into an isolated, sibling-free directory before extraction' do
+      call_it()
+
+      expect(@file_wrapper).to have_received(:mkdir_tmp).with(nil, isolation_parent)
+      expect(@file_wrapper).to have_received(:cp).with(filepath, isolated_filepath)
+    end
+
+    it 'builds the bare-includes command against the isolated staged path, not the original' do
+      call_it()
+
+      expect(@tool_executor).to have_received(:build_command_line)
+        .with(:bare_tool, [], isolated_filepath, [], [], [])
+    end
+
+    it 'returns the includes parsed from the staged file make-rule output' do
+      result = call_it()
+      expect(result.map(&:filename)).to contain_exactly('unity.h', 'mock_foo_func.h', 'other.h')
+    end
+
+    it 'cleans up the isolation directory after a successful run' do
+      call_it()
+      expect(@file_wrapper).to have_received(:rm_rf).with(isolation_dir)
+    end
+
+    it 'cleans up the isolation directory even when the tool executor raises' do
+      allow(@tool_executor).to receive(:exec).and_raise(StandardError.new('boom'))
+
+      expect { call_it() }.to raise_error(StandardError, 'boom')
+
+      expect(@file_wrapper).to have_received(:rm_rf).with(isolation_dir)
+    end
+
+    it 'still cleans self-reference against the original filepath identity, not the staged copy' do
+      self_ref_rules =
+        "test_other.o: #{isolated_filepath} #{filepath} other.h\n\n#{filepath}:\n\nother.h:\n"
+      allow(@tool_executor).to receive(:exec).and_return(output: self_ref_rules)
+
+      result = call_it()
+      expect(result.map(&:filename)).to contain_exactly('other.h')
+    end
+
+  end
+
+
   # ===========================================================================
   describe '#extract_user_includes_from_text' do
   # ===========================================================================

data/spec/units/system_wrapper_spec.rb

@@ -0,0 +1,72 @@
+# =========================================================================
+#   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/system_wrapper'
+
+describe SystemWrapper do
+  before(:each) do
+    @sys_wrapper = described_class.new
+  end
+
+  # Portable, real subprocess invocations -- no shell scripting, no signals (those are
+  # covered where they're actually consumed, via doubles, in generator_helper_spec.rb).
+  # This spec exists to characterize shell_capture3's own contract: it is the sole place
+  # a subprocess's real Process::Status is captured, and the one thing downstream crash
+  # detection depends on entirely.
+  def ruby_command(code)
+    "#{RbConfig.ruby} -e #{code.inspect}"
+  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
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 3'), boom: false )
+        expect(result[:exit_code]).to eq(0)
+      end
+
+      it 'still relays the real, un-neutered Process::Status' do
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 3'), boom: false )
+        expect(result[:status]).not_to be_nil
+        expect(result[:status].exitstatus).to eq(3)
+        expect(result[:status].success?).to be false
+      end
+
+      it 'forces exit_code to 0 for a genuinely successful subprocess too' do
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 0'), boom: false )
+        expect(result[:exit_code]).to eq(0)
+        expect(result[:status].success?).to be true
+      end
+    end
+
+    context 'boom: true' do
+      it 'surfaces the real nonzero exit code' do
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 3'), boom: true )
+        expect(result[:exit_code]).to eq(3)
+      end
+
+      it 'reports 0 for a genuinely successful subprocess' do
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 0'), boom: true )
+        expect(result[:exit_code]).to eq(0)
+      end
+
+      it 'still relays the same real Process::Status as boom: false does' do
+        result = @sys_wrapper.shell_capture3( command: ruby_command('exit 3'), boom: true )
+        expect(result[:status].exitstatus).to eq(3)
+      end
+    end
+
+    it 'combines stdout and stderr into :output while keeping each stream separately available' do
+      result = @sys_wrapper.shell_capture3(
+        command: ruby_command('STDOUT.print "out"; STDERR.print "err"'), boom: false
+      )
+      expect(result[:stdout]).to eq('out')
+      expect(result[:stderr]).to eq('err')
+      expect(result[:output]).to eq('outerr')
+    end
+  end
+end

data/spec/units/test_context_extractor_spec.rb

@@ -391,8 +391,8 @@ describe TestContextExtractor do
       @extractor.collect_context( filepath, input, TestContextExtractor::Context::TEST_RUNNER_DETAILS )
 
       expected = [
-        {:line_number =>  2, :test => 'test_this_function'},
-        {:line_number => 12, :test => 'test_another_function'},
+        {:line_number =>  2, :test => 'test_this_function', :symbol => 'test_this_function'},
+        {:line_number => 12, :test => 'test_another_function', :symbol => 'test_another_function'},
       ]
 
       expect( @extractor.lookup_test_cases( filepath ) ).to eq expected
@@ -411,7 +411,7 @@ describe TestContextExtractor do
         @extractor.collect_context( filepath, input, TestContextExtractor::Context::TEST_RUNNER_DETAILS )
       }.not_to raise_error
 
-      expected = [{ :line_number => 2, :test => 'test_this_function' }]
+      expected = [{ :line_number => 2, :test => 'test_this_function', :symbol => 'test_this_function' }]
       expect( @extractor.lookup_test_cases( filepath ) ).to eq expected
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ceedling
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
 - Mark VanderVoord
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -178,19 +178,31 @@ files:
 - assets/example_file_with_statics.c
 - assets/example_file_with_stdio.c
 - assets/example_file_with_stdio.h
+- assets/fake_crash_test_fixture.rb
+- assets/partial_all_module.h
 - assets/project.yml
+- assets/run_with_ubsan.rb
+- assets/same_dir_pairing_module.c
+- assets/same_dir_pairing_module.h
+- assets/same_dir_pairing_module_func.h
+- assets/same_dir_pairing_other.c
+- assets/same_dir_pairing_other.h
 - assets/test_example_file.c
 - assets/test_example_file_2.c
 - assets/test_example_file_boom.c
 - assets/test_example_file_crash_assert.c
 - assets/test_example_file_crash_sigsegv.c
+- assets/test_example_file_crash_sigsegv_with_param.c
 - assets/test_example_file_source_include.c
 - assets/test_example_file_success.c
+- assets/test_example_file_ub_shift_overflow.c
 - assets/test_example_file_unity_printf.c
 - assets/test_example_file_verbose.c
 - assets/test_example_file_with_mock.c
 - assets/test_example_file_with_stdio.c
 - assets/test_example_with_parameterized_tests.c
+- assets/test_partial_all_module.c
+- assets/test_same_dir_pairing.c
 - assets/tests_with_defines/src/adc_hardware.c
 - assets/tests_with_defines/src/adc_hardware.h
 - assets/tests_with_defines/src/adc_hardware_configurator.c
@@ -281,6 +293,7 @@ files:
 - docs/mkdocs/configuration/reference/index.md
 - docs/mkdocs/configuration/reference/libraries.md
 - docs/mkdocs/configuration/reference/mixins.md
+- docs/mkdocs/configuration/reference/partials.md
 - docs/mkdocs/configuration/reference/paths.md
 - docs/mkdocs/configuration/reference/plugins.md
 - docs/mkdocs/configuration/reference/project.md
@@ -807,6 +820,7 @@ files:
 - site-local/configuration/reference/index.html
 - site-local/configuration/reference/libraries.html
 - site-local/configuration/reference/mixins.html
+- site-local/configuration/reference/partials.html
 - site-local/configuration/reference/paths.html
 - site-local/configuration/reference/plugins.html
 - site-local/configuration/reference/project.html
@@ -946,6 +960,7 @@ files:
 - spec/units/c_extractor/c_extractor_integration_spec.rb
 - spec/units/c_extractor/c_extractor_preprocessing_spec.rb
 - spec/units/c_extractor/c_extractor_spec.rb
+- spec/units/config/configurator_setup_spec.rb
 - spec/units/config_matchinator_spec.rb
 - spec/units/config_walkinator_spec.rb
 - spec/units/configurator_builder_spec.rb
@@ -978,6 +993,7 @@ files:
 - spec/units/reportinator_spec.rb
 - spec/units/ruby_expandinator_spec.rb
 - spec/units/system_utils_spec.rb
+- spec/units/system_wrapper_spec.rb
 - spec/units/test_build_executor_spec.rb
 - spec/units/test_context_extractor_spec.rb
 - spec/units/tool_executor_helper_spec.rb
@@ -1792,6 +1808,7 @@ test_files:
 - spec/units/c_extractor/c_extractor_integration_spec.rb
 - spec/units/c_extractor/c_extractor_preprocessing_spec.rb
 - spec/units/c_extractor/c_extractor_spec.rb
+- spec/units/config/configurator_setup_spec.rb
 - spec/units/config_matchinator_spec.rb
 - spec/units/config_walkinator_spec.rb
 - spec/units/configurator_builder_spec.rb
@@ -1824,6 +1841,7 @@ test_files:
 - spec/units/reportinator_spec.rb
 - spec/units/ruby_expandinator_spec.rb
 - spec/units/system_utils_spec.rb
+- spec/units/system_wrapper_spec.rb
 - spec/units/test_build_executor_spec.rb
 - spec/units/test_context_extractor_spec.rb
 - spec/units/tool_executor_helper_spec.rb