ceedling 1.1.9 → 1.2.0

data/spec/units/plugins/report_tests_teamcity_stdout_spec.rb

@@ -0,0 +1,121 @@
+# =========================================================================
+#   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 'stringio'
+require 'ceedling/plugins/plugin'
+
+$: << File.expand_path('../../../../plugins/report_tests_teamcity_stdout/lib', __FILE__)
+require 'report_tests_teamcity_stdout'
+
+describe ReportTestsTeamcityStdout do
+  before(:each) do
+    @stream = StringIO.new
+    @plugin_reportinator = double('plugin_reportinator')
+
+    @plugin = described_class.allocate
+    @plugin.instance_variable_set(:@output_enabled, true)
+    @plugin.instance_variable_set(:@mutex, Mutex.new)
+    @plugin.instance_variable_set(:@flowid_count, 0)
+    @plugin.instance_variable_set(:@suites, {})
+    @plugin.instance_variable_set(:@stream, @stream)
+    @plugin.instance_variable_set(:@ceedling, { plugin_reportinator: @plugin_reportinator })
+  end
+
+  describe '#escape' do
+    it 'escapes pipe, single-quote, and brackets -- required for every TeamCity value' do
+      expect(@plugin.send(:escape, "a|b'c[d]e")).to eq("a||b|'c|[d|]e")
+    end
+  end
+
+  describe '#pre_test / #post_test' do
+    it 'assigns an incrementing flow id per test and brackets it with suite start/finish messages' do
+      @plugin.pre_test('test/TestFoo.c')
+      @plugin.post_test('test/TestFoo.c')
+
+      lines = @stream.string.lines
+      expect(lines[0]).to eq("##teamcity[testSuiteStarted name='TestFoo' flowId='1']\n")
+      expect(lines[1]).to eq("##teamcity[testSuiteFinished name='TestFoo' flowId='1']\n")
+    end
+
+    it 'gives each successive test its own flow id' do
+      @plugin.pre_test('test/TestFoo.c')
+      @plugin.pre_test('test/TestBar.c')
+
+      expect(@stream.string).to include("flowId='1']")
+      expect(@stream.string).to include("flowId='2']")
+    end
+
+    it 'does nothing at all when output is disabled' do
+      @plugin.instance_variable_set(:@output_enabled, false)
+      @plugin.pre_test('test/TestFoo.c')
+      @plugin.post_test('test/TestFoo.c')
+
+      expect(@stream.string).to be_empty
+    end
+  end
+
+  describe '#post_test_fixture_execute' do
+    before(:each) do
+      @plugin.instance_variable_get(:@suites)['test/TestFoo.c'] = { flowid: 1 }
+    end
+
+    it 'emits a started/finished pair per passing test, apportioning the executable duration evenly' do
+      allow(@plugin_reportinator).to receive(:assemble_test_results).and_return({
+        total_time: 1.0,
+        counts: { passed: 2, failed: 0 },
+        successes: [ { source: { dirname: 'test', basename: 'TestFoo.c' },
+                       collection: [ { test: 'test_a' }, { test: 'test_b' } ] } ],
+        failures: [], ignores: []
+      })
+
+      @plugin.post_test_fixture_execute(context: :test, test_filepath: 'test/TestFoo.c', result_file: 'x.pass')
+
+      expect(@stream.string).to include("testStarted name='test.test/TestFoo.test_a' flowId='1'")
+      expect(@stream.string).to include("testFinished name='test.test/TestFoo.test_a' duration='500' flowId='1'")
+    end
+
+    it 'emits a testFailed message naming the file, line, and escaped message for a failing test' do
+      allow(@plugin_reportinator).to receive(:assemble_test_results).and_return({
+        total_time: 0.5,
+        counts: { passed: 0, failed: 1 },
+        successes: [], ignores: [],
+        failures: [ { source: { dirname: 'test', basename: 'TestFoo.c', file: 'test/TestFoo.c' },
+                      collection: [ { test: 'test_c', line: 10, message: "Expected 'a'" } ] } ]
+      })
+
+      @plugin.post_test_fixture_execute(context: :test, test_filepath: 'test/TestFoo.c', result_file: 'x.fail')
+
+      expect(@stream.string).to include(
+        "testFailed name='test.test/TestFoo.test_c' message='Expected |'a|'' details='File: test/TestFoo.c Line: 10' flowId='1'"
+      )
+    end
+
+    it 'emits testIgnored (not started/finished) for an ignored test' do
+      allow(@plugin_reportinator).to receive(:assemble_test_results).and_return({
+        total_time: 0.0, counts: { passed: 0, failed: 0 },
+        successes: [], failures: [],
+        ignores: [ { source: { dirname: 'test', basename: 'TestFoo.c' }, collection: [ { test: 'test_d' } ] } ]
+      })
+
+      @plugin.post_test_fixture_execute(context: :test, test_filepath: 'test/TestFoo.c', result_file: 'x.ignore')
+
+      expect(@stream.string).to eq("##teamcity[testIgnored name='test.test/TestFoo.test_d' flowId='1']\n")
+    end
+  end
+
+  # A TeamCity service message must stay on one physical line
+  describe '#escape' do
+    it 'escapes a real newline as |n, keeping the whole message on one physical output line' do
+      expect(@plugin.send(:escape, "line one\nline two")).to eq('line one|nline two')
+    end
+
+    it 'escapes a real carriage return as |r' do
+      expect(@plugin.send(:escape, "line one\rline two")).to eq('line one|rline two')
+    end
+  end
+end

data/spec/units/plugins/reportgenerator_reportinator_spec.rb

@@ -0,0 +1,410 @@
+# =========================================================================
+#   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/tool_executor'
+require 'ceedling/constants'
+require 'ceedling/exceptions'
+require 'ceedling/file_path_utils'
+
+PROJECT_BUILD_ROOT           = 'build'     unless defined?(PROJECT_BUILD_ROOT)
+PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
+
+$: << File.expand_path('../../../../plugins/gcov/lib', __FILE__)
+
+require 'gcov_constants'
+require 'gcov_types'
+require 'gcov_reportinator'
+require 'reportgenerator_reportinator'
+
+TOOLS_GCOV_REPORTGENERATOR_REPORT = { name: 'gcov_reportgenerator_report' }.freeze unless defined?(TOOLS_GCOV_REPORTGENERATOR_REPORT)
+TOOLS_GCOV_REPORT                 = { name: 'gcov_report' }.freeze                 unless defined?(TOOLS_GCOV_REPORT)
+
+describe ReportGeneratorReportinator do
+  let(:loginator)        { double('loginator', log: nil, lazy: nil) }
+  let(:reportinator_obj) { double('reportinator', generate_heading: '', generate_progress: '') }
+  let(:tool_validator)   { double('tool_validator', validate: nil) }
+  let(:tool_executor)    { double('tool_executor') }
+  let(:batchinator)      { double('batchinator') }
+  let(:file_wrapper)     { double('file_wrapper') }
+  let(:configurator) do
+    double('configurator',
+      project_use_partials:     false,
+      collection_paths_test:    ['test'],
+      collection_paths_support: ['support'],
+      project_test_file_prefix: 'test_',
+      cmock_mock_prefix:        'Mock',
+      project_build_root:       'build',
+      extension_source:         ['.c']
+    )
+  end
+  let(:system_objects) do
+    {
+      tool_validator: tool_validator,
+      loginator:      loginator,
+      reportinator:   reportinator_obj,
+      tool_executor:  tool_executor,
+      configurator:   configurator,
+      batchinator:    batchinator,
+      file_wrapper:   file_wrapper,
+    }
+  end
+
+  let(:reportinator) { described_class.new(system_objects, {}) }
+
+  describe '#build_optional_args' do
+    it 'quotes flag and value together for the plain 1:1 options' do
+      rg_opts = { history_directory: '/tmp/hist', verbosity: 'Info', tag: 'v1' }
+      args = reportinator.send(:build_optional_args, rg_opts, 1)
+      expect(args).to include('"-historydir:/tmp/hist"')
+      expect(args).to include('"-verbosity:Info"')
+      expect(args).to include('"-tag:v1"')
+    end
+
+    # Finding A.3: these three settings were missing their leading '-', silently
+    # never applying createSubdirectoryForAllReportTypes/numberOfReports*InParallel.
+    # Confirmed directly against a real `reportgenerator` run (Docker): a leading '-'
+    # here makes reportgenerator log "Unknown command line parameter 'settings'" and
+    # the setting never applies -- unlike every other option in this table, these take
+    # NO leading dash.
+    it 'has no leading "-" on any settings: argument' do
+      rg_opts = { num_parallel_threads: 4 }
+      args = reportinator.send(:build_optional_args, rg_opts, 2)
+      expect(args).to include('"settings:createSubdirectoryForAllReportTypes=true"')
+      expect(args).to include('"settings:numberOfReportsParsedInParallel=4"')
+      expect(args).to include('"settings:numberOfReportsMergedInParallel=4"')
+      expect(args).to_not include('"-settings:')
+    end
+
+    it 'omits createSubdirectoryForAllReportTypes when only one report type is configured' do
+      args = reportinator.send(:build_optional_args, {}, 1)
+      expect(args).to_not include('createSubdirectoryForAllReportTypes')
+    end
+
+    it 'appends quoted :custom_args after the table-driven and settings arguments' do
+      rg_opts = { tag: 'v1', custom_args: ['-foo:bar'] }
+      args = reportinator.send(:build_optional_args, rg_opts, 1)
+      expect(args).to include('"-foo:bar"')
+    end
+
+    it 'emits minimumCoverageThresholds:* for each configured :fail_under_* option' do
+      rg_opts = { fail_under_line: 80, fail_under_branch: 70, fail_under_method: 60, fail_under_full_method: 50 }
+      args = reportinator.send(:build_optional_args, rg_opts, 1)
+      expect(args).to include('"minimumCoverageThresholds:lineCoverage=80"')
+      expect(args).to include('"minimumCoverageThresholds:branchCoverage=70"')
+      expect(args).to include('"minimumCoverageThresholds:methodCoverage=60"')
+      expect(args).to include('"minimumCoverageThresholds:fullMethodCoverage=50"')
+    end
+
+    it 'rejects a :fail_under_* threshold outside 1-100' do
+      expect {
+        reportinator.send(:build_optional_args, { fail_under_line: 0 }, 1)
+      }.to raise_error(CeedlingException, /:gcov ↳ :report_generator.*must be an integer percentage/)
+    end
+  end
+
+  describe '#collect_reportgenerator_opts' do
+    it 'does not mutate the caller-supplied config hash across repeated calls' do
+      shared_opts = { gcov_report_generator: { file_filters: 'user-filter' } }
+
+      reportinator.send(:collect_reportgenerator_opts, shared_opts)
+      reportinator.send(:collect_reportgenerator_opts, shared_opts)
+
+      # Each call should independently derive from the same untouched source value,
+      # not accumulate the previous call's auto-generated exclusions onto it.
+      expect(shared_opts[:gcov_report_generator][:file_filters]).to eq('user-filter')
+    end
+
+    it 'places user-provided :file_filters first, ahead of auto-generated exclusions' do
+      opts = { gcov_report_generator: { file_filters: 'user-filter' } }
+      result = reportinator.send(:collect_reportgenerator_opts, opts)
+      expect(result[:file_filters]).to start_with('user-filter;')
+    end
+
+    context 'when :project_use_partials is true' do
+      it 'appends a Ceedling-Partial exclusion after user filters and auto-generated exclusions' do
+        allow(configurator).to receive(:project_use_partials).and_return(true)
+        result = reportinator.send(:collect_reportgenerator_opts, { gcov_report_generator: { file_filters: 'user-filter' } })
+        expect(result[:file_filters]).to end_with(";-#{PARTIAL_FILENAME_PREFIX}*")
+      end
+
+      it 'still appends the Ceedling-Partial exclusion when no user :file_filters are configured' do
+        allow(configurator).to receive(:project_use_partials).and_return(true)
+        result = reportinator.send(:collect_reportgenerator_opts, { gcov_report_generator: {} })
+        expect(result[:file_filters]).to include("-#{PARTIAL_FILENAME_PREFIX}*")
+      end
+    end
+
+    it 'never inserts a Ceedling-Partial exclusion when :project_use_partials is false' do
+      result = reportinator.send(:collect_reportgenerator_opts, { gcov_report_generator: {} })
+      expect(result[:file_filters]).to_not include(PARTIAL_FILENAME_PREFIX)
+    end
+
+    it 'sets :file_filters from auto-generated exclusions alone when no user filter is configured' do
+      allow(configurator).to receive(:collection_paths_test).and_return(['test'])
+      allow(configurator).to receive(:project_build_root).and_return('build')
+      result = reportinator.send(:collect_reportgenerator_opts, { gcov_report_generator: {} })
+      expect(result[:file_filters]).to eq('-./test/**/*;-./build/**/*')
+    end
+
+    it 'combines user :file_filters, auto-generated exclusions, and (when enabled) the partials exclusion in that exact order' do
+      allow(configurator).to receive(:project_use_partials).and_return(true)
+      allow(configurator).to receive(:collection_paths_test).and_return(['test'])
+      allow(configurator).to receive(:project_build_root).and_return('build')
+      result = reportinator.send(:collect_reportgenerator_opts, { gcov_report_generator: { file_filters: 'user-filter' } })
+      expect(result[:file_filters]).to eq("user-filter;-./test/**/*;-./build/**/*;-#{PARTIAL_FILENAME_PREFIX}*")
+    end
+  end
+
+  describe '#build_filefilter_exclusions' do
+    it 'emits a -./path/**/* glob exclusion for every configured test path' do
+      allow(configurator).to receive(:collection_paths_test).and_return(['test', 'more_tests'])
+      patterns = reportinator.send(:build_filefilter_exclusions)
+      expect(patterns).to include('-./test/**/*')
+      expect(patterns).to include('-./more_tests/**/*')
+    end
+
+    it 'emits a -./build_root/**/* glob exclusion' do
+      allow(configurator).to receive(:project_build_root).and_return('build')
+      patterns = reportinator.send(:build_filefilter_exclusions)
+      expect(patterns).to include('-./build/**/*')
+    end
+
+    it 'uses a literal-prefixed glob, not a regex, so a similarly-named directory does not match' do
+      allow(configurator).to receive(:collection_paths_test).and_return(['test'])
+      pattern = reportinator.send(:build_filefilter_exclusions).first
+      glob = pattern.delete_prefix('-')
+      expect(File.fnmatch(glob, './latest/test_bar.c', File::FNM_PATHNAME)).to eq(false)
+      expect(File.fnmatch(glob, './test/test_bar.c', File::FNM_PATHNAME)).to eq(true)
+    end
+  end
+
+  describe '#build_gcno_exclusions' do
+    it 'escapes regex metacharacters in test_prefix and mock_prefix' do
+      allow(configurator).to receive(:project_test_file_prefix).and_return('test.')
+      allow(configurator).to receive(:cmock_mock_prefix).and_return('Mock+')
+
+      exclusions = reportinator.send(:build_gcno_exclusions)
+      combined = (exclusions[:basename] + exclusions[:build_root_scoped]).join('|')
+      expect(combined).to include('test\\.')
+      expect(combined).to include('Mock\\+')
+    end
+
+    it 'places test_prefix in the basename bucket and mock/runner/framework fragments in the build_root_scoped bucket' do
+      exclusions = reportinator.send(:build_gcno_exclusions)
+      expect(exclusions[:basename].join('|')).to include('test_')
+      expect(exclusions[:build_root_scoped].join('|')).to include('Mock')
+      expect(exclusions[:build_root_scoped].join('|')).to include('_runner')
+    end
+  end
+
+  describe '#build_gcno_exclude_regex' do
+    it 'strips a trailing .gcov or .gcno suffix from user-supplied exclusion patterns' do
+      rg_opts = { gcov_exclude: ['legacy_code.gcov', 'other_file.gcno'] }
+      regex = reportinator.send(:build_gcno_exclude_regex, rg_opts)
+      expect('/build/gcov/out/legacy_code.gcno').to match(regex)
+      expect('/build/gcov/out/other_file.gcno').to match(regex)
+    end
+
+    it 'returns nil when there are no user or auto-generated exclusions' do
+      allow(configurator).to receive(:project_test_file_prefix).and_return('')
+      allow(configurator).to receive(:cmock_mock_prefix).and_return('')
+      # build_gcno_exclusions always contributes its own fixed patterns (test prefix,
+      # mock prefix, _runner, unity, cmock), so this documents that nil is only
+      # reachable if none of those match either -- not exercised further here.
+      rg_opts = { gcov_exclude: [] }
+      expect( reportinator.send(:build_gcno_exclude_regex, rg_opts) ).to_not be_nil
+    end
+
+    it 'matches a user-supplied exclusion pattern with no .gcov/.gcno suffix at all' do
+      regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: ['legacy_code'] })
+      expect('/build/gcov/out/legacy_code.gcno').to match(regex)
+    end
+
+    it 'matches both a user-supplied pattern and an auto-generated pattern from the same combined regex' do
+      regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: ['legacy_code'] })
+      expect('src/legacy_code.gcno').to match(regex)
+      expect('build/gcov/out/test_foo.gcno').to match(regex)
+    end
+
+    # Mock/runner/framework filename fragments only identify files Ceedling itself
+    # generates under :build_root, so a match additionally requires a :build_root
+    # path-segment ancestor. This regex gates whether gcov is invoked on a file at all,
+    # so an unscoped match would silently and permanently drop that file's coverage data,
+    # for any report type.
+    context 'build_root scoping for mock/runner/framework fragments' do
+      it 'does not match a production file merely containing the mock prefix as a substring, outside build_root' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('src/MockupRenderer.gcno').to_not match(regex)
+      end
+
+      it 'does not match a production file merely containing "_runner" as a substring, outside build_root' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('src/task_runner_queue.gcno').to_not match(regex)
+      end
+
+      it 'does not match a file under a directory that merely contains build_root as a substring (e.g. "rebuild")' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('rebuild/thing/MockFoo.gcno').to_not match(regex)
+      end
+
+      it 'still matches a legitimate generated mock under build_root' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('build/gcov/out/test_foo/MockBar.gcno').to match(regex)
+      end
+
+      it 'still matches a legitimate generated test runner under build_root' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('build/gcov/out/test_foo/test_foo_runner.gcno').to match(regex)
+      end
+
+      it 'still matches unity.gcno and cmock.gcno under build_root' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('build/gcov/out/unity.gcno').to match(regex)
+        expect('build/gcov/out/cmock.gcno').to match(regex)
+      end
+
+      it 'does not build-root-scope user-supplied :gcov_exclude patterns' do
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: ['legacy_code'] })
+        expect('src/legacy_code.gcno').to match(regex)
+      end
+
+      it 'matches under build_root the same way whether or not it is configured with a leading "./"' do
+        allow(configurator).to receive(:project_build_root).and_return('./build')
+        regex = reportinator.send(:build_gcno_exclude_regex, { gcov_exclude: [] })
+        expect('build/gcov/out/test_foo/MockBar.gcno').to match(regex)
+      end
+    end
+  end
+
+  describe '#build_report_types' do
+    it 'maps configured report types to ReportGenerator names, silently dropping unrecognized ones' do
+      result = reportinator.send(:build_report_types, { gcov_reports: ['HtmlBasic', 'Cobertura', 'NotARealType'] })
+      expect(result).to eq(['HtmlSummary', 'Cobertura'])
+    end
+  end
+
+  # All real filesystem I/O in this class is routed through @file_wrapper --
+  # no real files or directories are touched by any spec in this describe block.
+  describe '#run_gcov' do
+    def stub_exec(exit_code:, output:)
+      allow(tool_executor).to receive(:build_command_line).and_return({ options: {} })
+      # A failed run under :boom false reports a zero exit code with a failed process status
+      status = instance_double(Process::Status, success?: exit_code == 0, exitstatus: exit_code)
+      allow(tool_executor).to receive(:exec).and_return({ exit_code: 0, output: output, status: status })
+      allow(tool_executor).to receive(:failed?) { |result| ToolExecutor.allocate.failed?( result ) }
+    end
+
+    it 'renames the file gcov reports creating, extracted from "Creating \'file.gcov\'" output' do
+      stub_exec(exit_code: 0, output: "Creating 'a1b2.gcov'\n")
+      allow(file_wrapper).to receive(:exist?).with('a1b2.gcov').and_return(true)
+      expect(file_wrapper).to receive(:mv).with('a1b2.gcov', File.join('build/gcov/out/test_foo', 'a1b2.gcov'))
+      reportinator.send(:run_gcov, 'build/gcov/out/test_foo/foo.c.gcno', '/proj/')
+    end
+
+    it 'renames every file mentioned across multiple "Creating" lines in one invocation' do
+      stub_exec(exit_code: 0, output: "Creating 'a1b2.gcov'\nCreating 'c3d4.gcov'\n")
+      allow(file_wrapper).to receive(:exist?).and_return(true)
+      expect(file_wrapper).to receive(:mv).with('a1b2.gcov', anything)
+      expect(file_wrapper).to receive(:mv).with('c3d4.gcov', anything)
+      reportinator.send(:run_gcov, 'build/gcov/out/test_foo/foo.c.gcno', '/proj/')
+    end
+
+    it 'skips the rename when the file does not exist' do
+      stub_exec(exit_code: 0, output: "Creating 'a1b2.gcov'\n")
+      allow(file_wrapper).to receive(:exist?).and_return(false)
+      expect(file_wrapper).to_not receive(:mv)
+      reportinator.send(:run_gcov, 'build/gcov/out/test_foo/foo.c.gcno', '/proj/')
+    end
+
+    it 'skips the rename when source and destination are already identical' do
+      stub_exec(exit_code: 0, output: "Creating 'build/gcov/out/test_foo/a1b2.gcov'\n")
+      allow(file_wrapper).to receive(:exist?).and_return(true)
+      expect(file_wrapper).to_not receive(:mv)
+      reportinator.send(:run_gcov, 'build/gcov/out/test_foo/foo.c.gcno', '/proj/')
+    end
+
+    it 'logs a COMPLAIN on non-zero exit but still proceeds to scan and rename (documented non-fatal behavior)' do
+      stub_exec(exit_code: 1, output: "Creating 'a1b2.gcov'\n")
+      allow(file_wrapper).to receive(:exist?).and_return(true)
+      expect(loginator).to receive(:log).with(/could not process/, Verbosity::COMPLAIN)
+      expect(file_wrapper).to receive(:mv)
+      reportinator.send(:run_gcov, 'build/gcov/out/test_foo/foo.c.gcno', '/proj/')
+    end
+  end
+
+  describe '#generate_gcov_files' do
+    it 'discovers directories containing .gcno files and dispatches sorted, per-dir work to the batchinator' do
+      allow(file_wrapper).to receive(:directory_listing)
+        .with(File.join(GCOV_BUILD_OUTPUT_PATH, '**', "*#{EXTENSION_GCNO}"))
+        .and_return([
+          'build/gcov/out/test_foo/src/foo.c.gcno',
+          'build/gcov/out/test_foo/src/ceedling_partial_foo_impl.c.gcno',
+        ])
+      allow(file_wrapper).to receive(:directory_listing)
+        .with(File.join('build/gcov/out/test_foo/src', "*#{EXTENSION_GCNO}"))
+        .and_return([
+          # Deliberately listed partial-first -- generate_gcov_files must still sort the
+          # partial after its non-partial counterpart regardless of listing order.
+          'build/gcov/out/test_foo/src/ceedling_partial_foo_impl.c.gcno',
+          'build/gcov/out/test_foo/src/foo.c.gcno',
+        ])
+
+      dispatched = nil
+      allow(batchinator).to receive(:exec) { |workload:, things:, &_blk| dispatched = { workload: workload, things: things } }
+
+      reportinator.send(:generate_gcov_files, nil)
+
+      expect(dispatched[:workload]).to eq(:compile)
+      expect(dispatched[:things].length).to eq(1)
+      expect(dispatched[:things].first[:gcno_files]).to eq([
+        'build/gcov/out/test_foo/src/foo.c.gcno',
+        'build/gcov/out/test_foo/src/ceedling_partial_foo_impl.c.gcno',
+      ])
+    end
+
+    it 'excludes .gcno files matching gcno_exclude_regex, dropping a directory entirely once empty' do
+      allow(file_wrapper).to receive(:directory_listing)
+        .with(File.join(GCOV_BUILD_OUTPUT_PATH, '**', "*#{EXTENSION_GCNO}"))
+        .and_return(['build/gcov/out/test_foo/test_foo_runner.c.gcno'])
+      allow(file_wrapper).to receive(:directory_listing)
+        .with(File.join('build/gcov/out/test_foo', "*#{EXTENSION_GCNO}"))
+        .and_return(['build/gcov/out/test_foo/test_foo_runner.c.gcno'])
+
+      dispatched = nil
+      allow(batchinator).to receive(:exec) { |workload:, things:, &_blk| dispatched = things }
+
+      reportinator.send(:generate_gcov_files, /test_foo_runner/)
+
+      expect(dispatched).to eq([])
+    end
+  end
+
+  describe '#run_reportgenerator' do
+    it 'logs a COMPLAIN and returns nil without ever building a command when no .gcov files exist' do
+      allow(file_wrapper).to receive(:directory_listing).and_return([])
+      expect(tool_executor).to_not receive(:build_command_line)
+      expect(loginator).to receive(:log).with(/No matching \.gcno coverage files found/, Verbosity::COMPLAIN)
+
+      result = reportinator.send(:run_reportgenerator, { gcov_reports: [], collection_paths_source: [] }, {})
+      expect(result).to be_nil
+    end
+
+    it 'proceeds normally when .gcov files are present' do
+      allow(file_wrapper).to receive(:directory_listing).and_return(['build/gcov/out/test_foo/foo.c.gcov'])
+      allow(tool_executor).to receive(:build_command_line).and_return({})
+      expect(tool_executor).to receive(:exec).and_return({ exit_code: 0 })
+
+      result = reportinator.send(
+        :run_reportgenerator,
+        { gcov_reports: ['HtmlBasic'], collection_paths_source: ['src'] },
+        { file_filters: 'x' }
+      )
+      expect(result).to eq({ exit_code: 0 })
+    end
+  end
+end

data/spec/units/plugins/sanitize_config_spec.rb

@@ -0,0 +1,119 @@
+# =========================================================================
+#   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/exceptions'
+
+$: << File.expand_path('../../../../plugins/sanitize/lib', __FILE__)
+require 'sanitize_config'
+
+describe SanitizeConfig do
+  let(:defaults) do
+    { sanitizers: ['address', 'undefined'], recover: false, detect_leaks: true, test_builds: false, fail_build: true, runtime_options: {}, flags: {} }
+  end
+
+  def resolve(platform: :linux, **overrides)
+    return described_class.new( defaults.merge( overrides ), platform: platform )
+  end
+
+  describe 'flags' do
+    it 'instruments compiles to halt at the first finding, with stack frames kept' do
+      expect(resolve.compile_flags).to eq( ['-fsanitize=address,undefined', '-fno-sanitize-recover=all', '-fno-omit-frame-pointer', '-g'] )
+    end
+
+    it 'links the sanitizers\' runtimes' do
+      expect(resolve.link_flags).to eq( ['-fsanitize=address,undefined'] )
+    end
+
+    it 'leaves recovery on when asked to keep running after a finding' do
+      expect(resolve( recover: true ).compile_flags).not_to include( '-fno-sanitize-recover=all' )
+    end
+
+    it 'adds a project\'s own compile and link flags last' do
+      config = resolve( flags: { compile: ['-O1'], link: ['-static-libasan'] } )
+
+      expect(config.compile_flags.last).to eq( '-O1' )
+      expect(config.link_flags.last).to eq( '-static-libasan' )
+    end
+
+    # ASan's runtime includes leak detection
+    it 'checks leaks through ASan without a separate leak sanitizer' do
+      expect(resolve( sanitizers: ['address', 'leak'] ).compile_flags.first).to eq( '-fsanitize=address' )
+    end
+
+    it 'builds a leak sanitizer alone when ASan is not asked for' do
+      expect(resolve( sanitizers: ['leak'] ).compile_flags.first).to eq( '-fsanitize=leak' )
+    end
+  end
+
+  # Findings come from each report, not from the exit code. A halt leaves Unity's summary
+  # missing, which reads as a crash, and a leak at exit leaves a clean summary.
+  describe 'runtime environment' do
+    it 'halts at the first finding, prints stacks, and exits as the test would' do
+      expect(resolve.environment).to eq(
+        'ASAN_OPTIONS'  => 'halt_on_error=1:exitcode=0:detect_leaks=1',
+        'UBSAN_OPTIONS' => 'halt_on_error=1:print_stacktrace=1:exitcode=0'
+      )
+    end
+
+    it 'keeps running after a finding when asked to recover' do
+      expect(resolve( recover: true ).environment['UBSAN_OPTIONS']).to start_with( 'halt_on_error=0' )
+    end
+
+    it 'turns leak checking off when asked' do
+      expect(resolve( detect_leaks: false ).environment['ASAN_OPTIONS']).to include( 'detect_leaks=0' )
+    end
+
+    it 'sets the leak sanitizer\'s own options when it runs alone' do
+      expect(resolve( sanitizers: ['leak'] ).environment).to eq( 'LSAN_OPTIONS' => 'exitcode=0' )
+    end
+
+    it 'adds a project\'s own runtime options last' do
+      config = resolve( runtime_options: { asan: ['strict_string_checks=1'], ubsan: ['report_error_type=1'] } )
+
+      expect(config.environment['ASAN_OPTIONS']).to end_with( ':strict_string_checks=1' )
+      expect(config.environment['UBSAN_OPTIONS']).to end_with( ':report_error_type=1' )
+    end
+  end
+
+  # LeakSanitizer is not supported on macOS, where ASan aborts when asked to check leaks
+  describe 'on macOS' do
+    it 'never asks ASan to check leaks, with a notice' do
+      config = resolve( platform: :macos )
+
+      expect(config.environment['ASAN_OPTIONS']).not_to include( 'detect_leaks' )
+      expect(config.notices).to include( /leak.*not supported on macOS/i )
+    end
+
+    it 'drops a requested leak sanitizer, with a notice' do
+      config = resolve( sanitizers: ['address', 'leak'], platform: :macos )
+
+      expect(config.sanitizers).to eq( [:address] )
+      expect(config.notices).to include( /leak.*not supported on macOS/i )
+    end
+  end
+
+  describe 'validation' do
+    it 'reads sanitizer names as symbols or strings in any letter case' do
+      expect(resolve( sanitizers: [:Address, 'UNDEFINED'] ).sanitizers).to eq( [:address, :undefined] )
+    end
+
+    it 'rejects an unknown sanitizer, listing the choices' do
+      expect { resolve( sanitizers: ['thread'] ) }.to raise_error(
+        CeedlingException, /:sanitize ↳ :sanitizers entry `thread` is not a supported sanitizer. Choose from :address, :undefined, :leak./
+      )
+    end
+
+    it 'rejects an empty sanitizer list' do
+      expect { resolve( sanitizers: [] ) }.to raise_error( CeedlingException, /:sanitize ↳ :sanitizers names no sanitizer/ )
+    end
+
+    it 'rejects a setting that is not a boolean' do
+      expect { resolve( recover: 'false' ) }.to raise_error( CeedlingException, /:sanitize ↳ :recover must be TRUE or FALSE/ )
+    end
+  end
+end