ceedling 1.1.10 → 1.2.0

data/spec/units/generators/generator_spec.rb

@@ -0,0 +1,317 @@
+# =========================================================================
+#   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/generators/generator'
+require 'ceedling/constants'
+
+# Scoped to Generator#generate_object_file_c's choice of which file the compiler receives,
+# and to where Generator#generate_mock has CMock write a mock.
+describe Generator do
+  before(:each) do
+    @tool_executor  = double('tool_executor')
+    @plugin_manager = double('plugin_manager')
+
+    allow(@tool_executor).to receive(:build_command_line).and_return( { line: 'gcc', options: {} } )
+    allow(@tool_executor).to receive(:exec).and_return( { output: '', exit_code: 0 } )
+    allow(@plugin_manager).to receive(:pre_compile_execute)
+    allow(@plugin_manager).to receive(:post_compile_execute)
+
+    @collaborators = collaborators = [
+      :configurator, :generator_helper, :generator_mocks, :generator_test_results,
+      :generator_test_results_backtrace, :generator_partials, :test_context_extractor,
+      :file_finder, :file_path_utils, :reportinator, :loginator, :test_runner_manager,
+      :system_wrapper, :file_wrapper
+    ].to_h { |name| [name, double( name.to_s ).as_null_object] }
+
+    @generator_mocks = double('generator_mocks')
+    @cmock           = double('cmock', setup_mocks: nil)
+    allow(@generator_mocks).to receive(:build_configuration).and_return( {} )
+    allow(@generator_mocks).to receive(:manufacture).and_return( @cmock )
+    allow(@plugin_manager).to receive(:pre_mock_generate)
+    allow(@plugin_manager).to receive(:post_mock_generate)
+
+    @generator = described_class.new(
+      collaborators.merge( tool_executor: @tool_executor, plugin_manager: @plugin_manager, generator_mocks: @generator_mocks )
+    )
+  end
+
+  def compile(**extra)
+    @generator.generate_object_file_c(
+      tool: :compiler, module_name: 'test_gpio', context: :test,
+      source: 'src/gpio.c', object: 'build/gpio.o', **extra
+    )
+  end
+
+  describe '#generate_object_file_c' do
+    it 'hands the compiler the source itself by default' do
+      compile()
+
+      expect(@tool_executor).to have_received(:build_command_line).with( :compiler, [], 'src/gpio.c', any_args )
+    end
+
+    # An isolated copy is what compiles, but plugins and logs report the real source.
+    it 'hands the compiler compile_source while plugins still see the original source' do
+      compile( compile_source: 'build/tmp1/gpio.c' )
+
+      expect(@tool_executor).to have_received(:build_command_line).with( :compiler, [], 'build/tmp1/gpio.c', any_args )
+      expect(@plugin_manager).to have_received(:pre_compile_execute).with( hash_including( source: 'src/gpio.c' ) )
+      expect(@plugin_manager).to have_received(:post_compile_execute).with( hash_including( source: 'src/gpio.c' ) )
+    end
+  end
+
+  describe '#generate_test_results' do
+    before(:each) do
+      allow(@collaborators[:generator_helper]).to receive(:test_crash?).and_return( false )
+      allow(@collaborators[:test_runner_manager]).to receive(:collect_cmdline_args).and_return( ['-n test_a'] )
+      allow(@plugin_manager).to receive(:pre_test_fixture_execute)
+      allow(@plugin_manager).to receive(:post_test_fixture_execute)
+    end
+
+    # A fixture tool that wraps the test executable runs it as its own last argument
+    it 'hands the fixture tool Unity\'s test case filters after its own arguments' do
+      @generator.generate_test_results(
+        tool: :fixture, context: :test, test_name: 'test_a', test_filepath: 'test/test_a.c',
+        executable: 'build/test_a.out', result: 'build/test_a.pass'
+      )
+
+      expect(@tool_executor).to have_received(:build_command_line).with( :fixture, [], 'build/test_a.out', trailing: ['-n test_a'] )
+    end
+  end
+
+  describe '#generate_test_results with a crash' do
+    let(:backtrace) { @collaborators[:generator_test_results_backtrace] }
+    let(:results)   { @collaborators[:generator_test_results] }
+
+    def run(tool: :fixture, use_backtrace: :none, explanation: nil, details: nil, heading: nil)
+      allow(@collaborators[:configurator]).to receive(:project_config_hash).and_return( { project_use_backtrace: use_backtrace } )
+      allow(@plugin_manager).to receive(:explain_test_crash) do |arg_hash|
+        arg_hash[:explanation] = explanation
+        arg_hash[:explanation_details] = details
+        arg_hash[:explanation_heading] = heading
+      end
+
+      @generator.generate_test_results(
+        tool: tool, context: :test, test_name: 'test_a', test_filepath: 'test/test_a.c',
+        executable: 'build/test_a.out', result: 'build/test_a.pass'
+      )
+    end
+
+    before(:each) do
+      allow(@collaborators[:generator_helper]).to receive(:test_crash?).and_return( true )
+      allow(@collaborators[:test_context_extractor]).to receive(:lookup_test_cases).and_return( [] )
+      allow(results).to receive(:filter_test_cases) { |cases| cases }
+      allow(@plugin_manager).to receive(:pre_test_fixture_execute)
+      allow(@plugin_manager).to receive(:post_test_fixture_execute)
+    end
+
+    it 'fails a crashed test with the cause a plugin names for it' do
+      run( explanation: 'ASan heap-buffer-overflow at src/a.c:9' )
+      expect(results).to have_received(:create_crash_failure).with( 'test_a.c', anything, [], message: 'ASan heap-buffer-overflow at src/a.c:9' )
+    end
+
+    it 'fails a crashed test with the cause\'s details alongside it' do
+      run( explanation: 'ASan heap-buffer-overflow at src/a.c:9', details: ['Boom log: x.log'] )
+      expect(results).to have_received(:create_crash_failure).with( 'test_a.c', anything, [], message: 'ASan heap-buffer-overflow at src/a.c:9 (Boom log: x.log)' )
+    end
+
+    it 'logs a plugin\'s explanation in place of the generic crash notice' do
+      run( explanation: 'ASan heap-buffer-overflow at src/a.c:9', details: ['Boom log: x.log'], heading: 'was stopped by a sanitizer finding' )
+
+      explanation = { heading: 'was stopped by a sanitizer finding', cause: 'ASan heap-buffer-overflow at src/a.c:9', details: ['Boom log: x.log'] }
+      expect(@collaborators[:generator_helper]).to have_received(:log_explained_crash).with( 'build/test_a.out', explanation )
+      expect(@collaborators[:generator_helper]).not_to have_received(:log_test_results_crash)
+    end
+
+    it 'logs the generic crash notice when no plugin names a cause' do
+      run()
+      expect(@collaborators[:generator_helper]).to have_received(:log_test_results_crash)
+      expect(@collaborators[:generator_helper]).not_to have_received(:log_explained_crash)
+    end
+
+    it 'tells the plugins which explanation reaches the crash notice' do
+      notices = []
+      allow(@collaborators[:configurator]).to receive(:project_config_hash).and_return( { project_use_backtrace: :none } )
+      allow(@plugin_manager).to receive(:explain_test_crash) { |arg_hash| notices << arg_hash[:crash_notice] }
+      @generator.generate_test_results(
+        tool: :fixture, context: :test, test_name: 'test_a', test_filepath: 'test/test_a.c', executable: 'build/test_a.out', result: 'build/test_a.pass'
+      )
+      expect(notices).to eq( [true] )
+    end
+
+    it 'asks the plugins once for a crash without backtraces' do
+      run( explanation: 'ASan heap-buffer-overflow at src/a.c:9' )
+      expect(@plugin_manager).to have_received(:explain_test_crash).once
+    end
+
+    it 'fails a crashed test as a crash when no plugin names a cause' do
+      run()
+      expect(results).to have_received(:create_crash_failure).with( 'test_a.c', anything, [], message: 'Test executable crashed' )
+    end
+
+    it 'has each simple backtrace rerun explained by the plugins' do
+      run( use_backtrace: :simple )
+      expect(backtrace).to have_received(:do_simple).with( 'test_a.c', 'build/test_a.out', anything, [], context: :test, tool: :fixture, explain: kind_of(Proc) )
+    end
+
+    # A tool that runs the reruns itself can't run under gdb
+    it 'falls back to simple backtraces, with a notice, for a fixture tool that runs its own reruns' do
+      run( tool: { name: 'wrapper', backtrace_rerun: true }, use_backtrace: :gdb )
+
+      expect(backtrace).to have_received(:do_simple)
+      expect(backtrace).not_to have_received(:do_gdb)
+      expect(@collaborators[:loginator]).to have_received(:log).with( /:use_backtrace .*:gdb.*:simple/, Verbosity::NORMAL )
+    end
+  end
+
+  # Test fixtures crash independently, but the fallback is the same for all of them
+  describe 'the :gdb fallback notice' do
+    before(:each) do
+      allow(@collaborators[:generator_helper]).to receive(:test_crash?).and_return( true )
+      allow(@collaborators[:test_context_extractor]).to receive(:lookup_test_cases).and_return( [] )
+      allow(@collaborators[:generator_test_results]).to receive(:filter_test_cases) { |cases| cases }
+      allow(@collaborators[:configurator]).to receive(:project_config_hash).and_return( { project_use_backtrace: :gdb } )
+      allow(@plugin_manager).to receive(:pre_test_fixture_execute)
+      allow(@plugin_manager).to receive(:post_test_fixture_execute)
+      allow(@plugin_manager).to receive(:explain_test_crash)
+    end
+
+    def crash(test)
+      @generator.generate_test_results(
+        tool: { name: 'wrapper', backtrace_rerun: true }, context: :sanitize, test_name: test, test_filepath: "test/#{test}.c",
+        executable: "build/#{test}.out", result: "build/#{test}.pass"
+      )
+    end
+
+    it 'is logged once for a build with several crashes, though each falls back' do
+      crash( 'test_a' )
+      crash( 'test_b' )
+
+      expect(@collaborators[:generator_test_results_backtrace]).to have_received(:do_simple).twice
+      expect(@collaborators[:loginator]).to have_received(:log).with( /:use_backtrace .*:gdb.*:simple/, Verbosity::NORMAL ).once
+    end
+
+    it 'tells the crash notice that :gdb can\'t be used' do
+      crash( 'test_a' )
+      expect(@collaborators[:generator_helper]).to have_received(:log_test_results_crash).with( 'build/test_a.out', anything, :simple, gdb_unavailable: true )
+    end
+  end
+
+  # On macOS, startup can find gdb unable to attach and fall back to :simple backtraces
+  describe 'crash advice after startup ruled out :gdb' do
+    before(:each) do
+      allow(@collaborators[:generator_helper]).to receive(:test_crash?).and_return( true )
+      allow(@collaborators[:test_context_extractor]).to receive(:lookup_test_cases).and_return( [] )
+      allow(@collaborators[:generator_test_results]).to receive(:filter_test_cases) { |cases| cases }
+      allow(@collaborators[:configurator]).to receive(:project_config_hash).and_return( { project_use_backtrace: :simple } )
+      allow(@plugin_manager).to receive(:pre_test_fixture_execute)
+      allow(@plugin_manager).to receive(:post_test_fixture_execute)
+      allow(@plugin_manager).to receive(:explain_test_crash)
+    end
+
+    def crash(state)
+      allow(@collaborators[:configurator]).to receive(:gdb_backtrace_state).and_return( state )
+      @generator.generate_test_results(
+        tool: :fixture, context: :test, test_name: 'test_a', test_filepath: 'test/test_a.c', executable: 'build/test_a.out', result: 'build/test_a.pass'
+      )
+    end
+
+    it 'tells the crash notice that :gdb can\'t be used' do
+      crash( :fell_back )
+      expect(@collaborators[:generator_helper]).to have_received(:log_test_results_crash).with( 'build/test_a.out', anything, :simple, gdb_unavailable: true )
+    end
+
+    it 'leaves the advice to the crash notice when startup never asked about gdb' do
+      crash( :unknown )
+      expect(@collaborators[:generator_helper]).to have_received(:log_test_results_crash).with( 'build/test_a.out', anything, :simple, gdb_unavailable: false )
+    end
+  end
+
+  describe '#generate_mock' do
+    def generate(**extra)
+      @generator.generate_mock(
+        context: :test, mock: :mock_config, test: 'test_both', input_filepath: 'src/drivers/uart/config.h',
+        output_path: 'build/test/mocks/test_both/drivers/uart', **extra
+      )
+    end
+
+    it 'has CMock write straight into the mock\'s directory without a folder' do
+      generate()
+
+      expect(@generator_mocks).to have_received(:build_configuration).with( 'build/test/mocks/test_both/drivers/uart', overrides: {} )
+      expect(@cmock).to have_received(:setup_mocks).with( 'src/drivers/uart/config.h', nil )
+    end
+
+    # CMock writes below its root at the folder, so the root is the directory less the folder
+    it 'roots CMock above the folder and hands it the folder, which names the mock' do
+      generate( folder: 'drivers/uart' )
+
+      expect(@generator_mocks).to have_received(:build_configuration).with( 'build/test/mocks/test_both', overrides: {} )
+      expect(@cmock).to have_received(:setup_mocks).with( 'src/drivers/uart/config.h', 'drivers/uart' )
+    end
+
+    it 'still reports the mock\'s own directory to plugins' do
+      generate( folder: 'drivers/uart' )
+
+      expect(@plugin_manager).to have_received(:pre_mock_generate).with( hash_including( output_path: 'build/test/mocks/test_both/drivers/uart' ) )
+    end
+  end
+  # Windows' Installer Detection would otherwise demand administrator rights for some names
+  describe '#generate_test_executable_manifest' do
+    let(:file_wrapper) { @collaborators[:file_wrapper] }
+    let(:loginator)    { @collaborators[:loginator] }
+
+    def generate(test_filepath: 'test/test_a.c', windows: true, existing: nil)
+      allow(@collaborators[:system_wrapper]).to receive(:windows?).and_return( windows )
+      allow(file_wrapper).to receive(:exist?).and_return( !existing.nil? )
+      allow(file_wrapper).to receive(:read).and_return( existing )
+      allow(file_wrapper).to receive(:write)
+      allow(loginator).to receive(:log)
+      @generator.generate_test_executable_manifest( executable: 'build/test_a.exe', test_filepath: test_filepath )
+    end
+
+    it 'writes the manifest beside the executable on Windows' do
+      generate()
+      expect(file_wrapper).to have_received(:write).with( 'build/test_a.exe.manifest', TEST_EXECUTABLE_MANIFEST )
+    end
+
+    it 'writes nothing elsewhere' do
+      generate( windows: false )
+      expect(file_wrapper).not_to have_received(:write)
+    end
+
+    it 'leaves an identical manifest alone' do
+      generate( existing: TEST_EXECUTABLE_MANIFEST )
+      expect(file_wrapper).not_to have_received(:write)
+    end
+
+    it 'replaces a manifest that differs' do
+      generate( existing: '<assembly/>' )
+      expect(file_wrapper).to have_received(:write).with( 'build/test_a.exe.manifest', TEST_EXECUTABLE_MANIFEST )
+    end
+
+    it 'notes a test filename Windows recognizes as an installer' do
+      generate( test_filepath: 'test/test_SetUp_parser.c' )
+      expect(loginator).to have_received(:log).with(
+        'Test filename `test_SetUp_parser.c` includes a keyword Windows recognizes as an installer (install, setup, update, patch) ' \
+        'when built as a test executable. As a defensive measure, Ceedling generated a manifest beside the test executable to run without ' \
+        'administrator privileges. Your toolchain may already embed a manifest that does the same.',
+        Verbosity::COMPLAIN
+      )
+    end
+
+    it 'notes nothing for an ordinary test filename' do
+      generate()
+      expect(loginator).not_to have_received(:log).with( anything, Verbosity::COMPLAIN )
+    end
+
+    it 'notes nothing off Windows' do
+      generate( test_filepath: 'test/test_patch.c', windows: false )
+      expect(loginator).not_to have_received(:log)
+    end
+  end
+end

data/spec/units/generators/generator_test_results_backtrace_spec.rb

@@ -99,7 +99,7 @@ GDB_WINDOWS_ASSERT_BRIEF_OUTPUT = <<~'GDB'.freeze
   [New Thread 4168.0xa14]
   [Thread 4168.0xa14 exited with code 3]
   [Inferior 1 (process 4168) exited with code 03]
-  Assertion failed: 0, file test/test_example_file_crash_assert.c, line 24
+  Assertion failed: 0, file test/test_nosanitize_crash_assert.c, line 24
 GDB
 
 # Windows assert(0) — signal ?, DLL abort frames, assertion text at end of output
@@ -110,13 +110,13 @@ GDB_WINDOWS_ASSERT_OUTPUT = <<~'GDB'.freeze
   #0  0x00007ff938364aee in ucrtbase!abort () from C:\Windows\System32\ucrtbase.dll
   #1  0x00007ff938320fb9 in ucrtbase!_isctype_l () from C:\Windows\System32\ucrtbase.dll
   #2  0x00007ff938382b01 in ucrtbase!_assert () from C:\Windows\System32\ucrtbase.dll
-  #3  0x00007ff691745367 in _assert (message=0x7ff691747026 "0", file=0x7ff691747000 "test/test_example_file_crash_assert.c", line=24)
-  #4  0x00007ff691741523 in test_add_numbers_triggers_assert () at test/test_example_file_crash_assert.c:24
-  #5  0x00007ff691741675 in run_test (func=0x7ff6917414ff <test_add_numbers_triggers_assert>, name=0x7ff6917470d8 "test_add_numbers_triggers_assert", line_num=20) at build/test/runners/test_example_file_crash_assert_runner.c:77
-  #6  0x00007ff6917418ce in main (argc=3, argv=0x8000e0) at build/test/runners/test_example_file_crash_assert_runner.c:123
+  #3  0x00007ff691745367 in _assert (message=0x7ff691747026 "0", file=0x7ff691747000 "test/test_nosanitize_crash_assert.c", line=24)
+  #4  0x00007ff691741523 in test_add_numbers_triggers_assert () at test/test_nosanitize_crash_assert.c:24
+  #5  0x00007ff691741675 in run_test (func=0x7ff6917414ff <test_add_numbers_triggers_assert>, name=0x7ff6917470d8 "test_add_numbers_triggers_assert", line_num=20) at build/test/runners/test_nosanitize_crash_assert_runner.c:77
+  #6  0x00007ff6917418ce in main (argc=3, argv=0x8000e0) at build/test/runners/test_nosanitize_crash_assert_runner.c:123
   Kill the program being debugged? (y or n) [answered Y; input not from terminal]
   [Inferior 1 (process 8364) killed]
-  Assertion failed: 0, file test/test_example_file_crash_assert.c, line 24
+  Assertion failed: 0, file test/test_nosanitize_crash_assert.c, line 24
   gdb: unknown target exception 0xc0000409 at 0x7ff938364aee
 GDB
 
@@ -445,6 +445,89 @@ describe GeneratorTestResultsBacktrace do
       expect(crash_line).not_to include('(log: ')
       expect(crash_line).to include('(/build/logs/test/test_lib/test_asserting.gdb.log)')
     end
+
+    # A crashed test case that resolves to no useful gdb report is worth flagging on
+    # its own, not just silently folded into the generic crash message -- COMPLAIN
+    # level (not ERRORS/WARNING) because this is per-case noise, not yet evidence
+    # that gdb itself is broken. See `#report_gdb_attach_health` below for the
+    # stronger, whole-suite signal.
+    it 'logs a per-occurrence COMPLAIN message (default decorator) when a test case falls back to "no useful report"' do
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status })
+
+      expect(@loginator).to receive(:log)
+        .with(a_string_including('test_asserting'), Verbosity::COMPLAIN)
+
+      @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: :test )
+    end
+  end
+
+  # ── #report_gdb_attach_health ────────────────────────────────────────────────
+
+  describe '#report_gdb_attach_health' do
+    let(:filename)    { 'test_lib.c' }
+    let(:executable)  { 'build/test/out/test_lib/test_lib.out' }
+    let(:shell_result){ { exit_code: 1, output: '', time: 0.0 } }
+    let(:test_cases)  { [{ test: 'test_asserting', symbol: 'test_asserting', line_number: 8 }] }
+
+    before(:each) do
+      allow(@configurator).to receive(:project_build_tests_root).and_return('build/test')
+      allow(@configurator).to receive(:tools_test_backtrace_gdb).and_return({})
+    end
+
+    it 'logs nothing when no do_gdb call has ever run (no crash in this suite)' do
+      expect(@loginator).to_not receive(:log)
+        .with(anything, Verbosity::ERRORS, LogLabels::WARNING)
+
+      @backtrace.report_gdb_attach_health()
+    end
+
+    # This is the whole point: gdb explaining not one single crash across an entire
+    # suite is a materially stronger signal than any one hard-to-diagnose crash, and
+    # deserves exactly one summary -- not one per crashing test executable.
+    it 'logs one summary WARNING after multiple test executables all fell back to "no useful report"' do
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status })
+
+      @backtrace.do_gdb( 'test_lib.c', executable, shell_result.dup, test_cases, context: :test )
+      @backtrace.do_gdb( 'test_module.c', executable, shell_result.dup, test_cases, context: :test )
+
+      expect(@loginator).to receive(:log)
+        .with(a_string_including('test suite run'), Verbosity::ERRORS, LogLabels::WARNING).once
+
+      @backtrace.report_gdb_attach_health()
+    end
+
+    it 'does not log when at least one test executable in the suite got a useful report' do
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: GDB_SIGSEGV_OUTPUT, time: 0.5, exit_code: 139, stderr: '', status: @ok_status }
+      )
+      @backtrace.do_gdb(
+        'TestUsartModel.c', executable, shell_result.dup,
+        [{ test: 'testCrash', symbol: 'testCrash', line_number: 37 }], context: :test
+      )
+
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status })
+      @backtrace.do_gdb( 'test_lib.c', executable, shell_result.dup, test_cases, context: :test )
+
+      expect(@loginator).to_not receive(:log)
+        .with(anything, Verbosity::ERRORS, LogLabels::WARNING)
+
+      @backtrace.report_gdb_attach_health()
+    end
+
+    it 'only flushes once -- a second call logs nothing further without a new crash' do
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status })
+      @backtrace.do_gdb( filename, executable, shell_result.dup, test_cases, context: :test )
+
+      expect(@loginator).to receive(:log)
+        .with(anything, Verbosity::ERRORS, LogLabels::WARNING).once
+
+      @backtrace.report_gdb_attach_health()
+      @backtrace.report_gdb_attach_health()
+    end
   end
 
   # ── #do_simple ─────────────────────────────────────────────────────────────
@@ -630,6 +713,83 @@ describe GeneratorTestResultsBacktrace do
 
   # ── private #format_signal_label ───────────────────────────────────────────
 
+  # A plugin that swaps the fixture tool, such as one setting a sanitizer's runtime options,
+  # can have its reruns run the same way the main run was
+  describe '#do_simple rerun tool' do
+    let(:filename)     { 'test_lib.c' }
+    let(:executable)   { 'build/test/out/test_lib/test_lib.out' }
+    let(:test_cases)   { [{ test: 'test_empty', line_number: 3 }] }
+    let(:fixture)      { { name: 'default_test_fixture', executable: '${1}', arguments: [] } }
+    let(:rerun_tool)   { { name: 'default_test_fixture_simple_backtrace', executable: '${1}', arguments: ['${2}'] } }
+    let(:wrapper)      { { name: 'wrapper', executable: 'env', arguments: ['A=1', '${1}'], backtrace_rerun: true } }
+    let(:valgrind)     { { name: 'valgrind', executable: 'valgrind', arguments: ['--log-file=test_lib.log', '${1}'] } }
+
+    before(:each) do
+      allow(@configurator).to receive(:tools_test_fixture).and_return( fixture )
+      allow(@configurator).to receive(:tools_test_fixture_simple_backtrace).and_return( rerun_tool )
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status }
+      )
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout).and_return( 'regenerated' )
+    end
+
+    def rerun(tool)
+      @backtrace.do_simple( filename, executable, { exit_code: 1, output: '', time: 0.0 }, test_cases, context: :test, tool: tool )
+    end
+
+    it 'reruns through the dedicated backtrace tool when the fixture tool is the configured one' do
+      rerun( fixture )
+      expect(@tool_executor).to have_received(:build_command_line).with( rerun_tool, [], executable, '-n "test_empty"' )
+    end
+
+    # Valgrind writes one report per test, which a rerun through it would overwrite
+    it 'reruns through the dedicated backtrace tool when a swapped fixture tool does not ask for reruns' do
+      rerun( valgrind )
+      expect(@tool_executor).to have_received(:build_command_line).with( rerun_tool, [], executable, '-n "test_empty"' )
+    end
+
+    it 'reruns through a swapped fixture tool that asks for reruns, with the test case filter after its arguments' do
+      rerun( wrapper )
+      expect(@tool_executor).to have_received(:build_command_line).with( wrapper, [], executable, trailing: ['-n "test_empty"'] )
+    end
+  end
+
+  describe '#do_simple crash explanations' do
+    let(:filename)   { 'test_lib.c' }
+    let(:executable) { 'build/test/out/test_lib/test_lib.out' }
+    let(:test_cases) { [{ test: 'test_crashes', line_number: 20 }] }
+
+    before(:each) do
+      allow(@configurator).to receive(:tools_test_fixture_simple_backtrace).and_return( {} )
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status }
+      )
+    end
+
+    def crashed_lines(explain)
+      lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) { |**kwargs| lines = kwargs[:output]; 'regenerated' }
+      @backtrace.do_simple( filename, executable, { exit_code: 1, output: '', time: 0.0 }, test_cases, context: :test, explain: explain )
+      return lines
+    end
+
+    it 'fails a crashed case with the cause named for its own rerun' do
+      lines = crashed_lines( ->(_crash_result) { 'ASan heap-buffer-overflow at src/lib.c:5' } )
+      expect(lines.first).to start_with( 'test_lib.c:20:test_crashes:FAIL: ASan heap-buffer-overflow at src/lib.c:5' )
+    end
+
+    # The named cause is where its full report lives, so the rerun's raw output is left out
+    it 'leaves a crashed case\'s raw output out of the message when a cause is named' do
+      lines = crashed_lines( ->(_crash_result) { 'ASan heap-buffer-overflow at src/lib.c:5' } )
+      expect(lines.first).to eq( 'test_lib.c:20:test_crashes:FAIL: ASan heap-buffer-overflow at src/lib.c:5' )
+    end
+
+    it 'fails a crashed case as a crash when nothing names a cause' do
+      lines = crashed_lines( ->(_crash_result) { nil } )
+      expect(lines.first).to start_with( 'test_lib.c:20:test_crashes:FAIL: Test case crashed' )
+    end
+  end
+
   describe '#format_signal_label (private)' do
     subject { |ex| @backtrace.send(:format_signal_label, ex.metadata[:output]) }
 
@@ -735,7 +895,7 @@ describe GeneratorTestResultsBacktrace do
     end
 
     it 'returns nil for brief Windows assert-only output' do
-      result = @backtrace.send(:extract_source_line, GDB_WINDOWS_ASSERT_BRIEF_OUTPUT, 'test_add_numbers_triggers_assert', 'test_example_file_crash_assert.c')
+      result = @backtrace.send(:extract_source_line, GDB_WINDOWS_ASSERT_BRIEF_OUTPUT, 'test_add_numbers_triggers_assert', 'test_nosanitize_crash_assert.c')
       expect(result).to be_nil
     end
   end
@@ -743,9 +903,9 @@ describe GeneratorTestResultsBacktrace do
   # ── private #format_signal_label (Windows brief form) → #do_gdb ──────────
 
   describe '#do_gdb with brief Windows assert (no crash frame)' do
-    let(:filename_assert)   { 'test_example_file_crash_assert.c' }
+    let(:filename_assert)   { 'test_nosanitize_crash_assert.c' }
     let(:test_cases_assert) { [{ test: 'test_add_numbers_triggers_assert', symbol: 'test_add_numbers_triggers_assert', line_number: 20 }] }
-    let(:executable)        { 'build/test/out/test_example_file_crash_assert/test_example_file_crash_assert.out' }
+    let(:executable)        { 'build/test/out/test_nosanitize_crash_assert/test_nosanitize_crash_assert.out' }
     let(:shell_result)      { { exit_code: 1, output: '', time: 0.0 } }
 
     before(:each) do

data/spec/units/generators/generator_test_results_sanity_checker_spec.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'spec_helper'
+require 'ceedling/filename_extension'
 require 'ceedling/generators/generator_test_results_sanity_checker'
 require 'ceedling/constants'
 require 'ceedling/loginator'
@@ -14,7 +15,7 @@ require 'ceedling/config/configurator'
 describe GeneratorTestResultsSanityChecker do
   before(:each) do
     # These will always be mocked
-    @loginator = Loginator.new({:verbosinator => nil, :file_wrapper => nil, :system_wrapper => nil})
+    @loginator = Loginator.new({:verbosinator => nil, :system_wrapper => nil})
     @configurator = Configurator.new({
       :configurator_setup => nil,
       :configurator_builder => nil,
@@ -27,6 +28,13 @@ describe GeneratorTestResultsSanityChecker do
       :ruby_expandinator => nil
     })
 
+    # Configurator generates its `extension_*` accessors at runtime from flattened
+    # project config (:extension ↳ :executable). These examples never run
+    # Configurator#build, so the method does not exist for partial-double verification
+    # to find, even though it is perfectly real in a running build. Declared on this
+    # instance so the stubs below stay verified rather than silently unchecked.
+    def @configurator.extension_executable; end
+
     @sanity_checker = described_class.new({:configurator => @configurator, :loginator => @loginator})
   
     @results = {}
@@ -62,7 +70,7 @@ describe GeneratorTestResultsSanityChecker do
     it 'rasies error if basic check fails for ignore' do
       @configurator.sanity_checks = TestResultsSanityChecks::NORMAL
       @results[:counts][:ignored] = 0
-      allow(@configurator).to receive(:extension_executable).and_return('')
+      allow(@configurator).to receive(:extension_executable).and_return(FilenameExtension.new(''))
       allow(@loginator).to receive(:log)
       expect{@sanity_checker.verify(@results, 3)}.to raise_error(RuntimeError)
     end
@@ -70,7 +78,7 @@ describe GeneratorTestResultsSanityChecker do
     it 'rasies error if basic check fails for failed' do
       @configurator.sanity_checks = TestResultsSanityChecks::NORMAL
       @results[:counts][:failed] = 0
-      allow(@configurator).to receive(:extension_executable).and_return('')
+      allow(@configurator).to receive(:extension_executable).and_return(FilenameExtension.new(''))
       allow(@loginator).to receive(:log)
       expect{@sanity_checker.verify(@results, 3)}.to raise_error(RuntimeError)
     end
@@ -78,21 +86,21 @@ describe GeneratorTestResultsSanityChecker do
     it 'rasies error if basic check fails for total' do
       @configurator.sanity_checks = TestResultsSanityChecks::NORMAL
       @results[:counts][:total] = 0
-      allow(@configurator).to receive(:extension_executable).and_return('')
+      allow(@configurator).to receive(:extension_executable).and_return(FilenameExtension.new(''))
       allow(@loginator).to receive(:log)
       expect{@sanity_checker.verify(@results, 3)}.to raise_error(RuntimeError)
     end
 
     it 'rasies error if thorough check fails for error code not 255 not equal' do
       @configurator.sanity_checks = TestResultsSanityChecks::THOROUGH
-      allow(@configurator).to receive(:extension_executable).and_return('')
+      allow(@configurator).to receive(:extension_executable).and_return(FilenameExtension.new(''))
       allow(@loginator).to receive(:log)
       expect{@sanity_checker.verify(@results, 2)}.to raise_error(RuntimeError)
     end
 
     it 'rasies error if thorough check fails for error code 255 less than 255' do
       @configurator.sanity_checks = TestResultsSanityChecks::THOROUGH
-      allow(@configurator).to receive(:extension_executable).and_return('')
+      allow(@configurator).to receive(:extension_executable).and_return(FilenameExtension.new(''))
       allow(@loginator).to receive(:log)
       expect{@sanity_checker.verify(@results, 255)}.to raise_error(RuntimeError)
     end