ceedling 1.1.9 → 1.2.0

data/lib/ceedling/generators/generator.rb

@@ -26,13 +26,19 @@ class Generator
               :reportinator,
               :loginator,
               :plugin_manager,
-              :test_runner_manager
+              :test_runner_manager,
+              :system_wrapper,
+              :file_wrapper
 
 
   def setup()
     # Aliases
     @helper = @generator_helper
     @backtrace = @generator_test_results_backtrace
+
+    # Test fixtures run in parallel, and the :gdb fallback is noted once per build
+    @mutex = Mutex.new
+    @gdb_fallback_noted = false
   end
 
   # A module's typedefs and aggregate definitions are identical regardless of whether a test
@@ -40,17 +46,27 @@ class Generator
   # rather than duplicated by generate_partial_implementation and generate_partial_interface.
   # Returns the bare generated filename (for the caller to add to each header's own includes
   # list) or nil when the module has no typedefs or aggregate definitions to share.
-  def generate_partial_types(name:, c_module:, output_path:)
+  def generate_partial_types(name:, partial:, c_module:, output_path:, includes: [], include_guard: nil)
+    msg = @reportinator.generate_module_progress(
+      operation: "Generating shared Partial types for",
+      module_name: name,
+      filename: partial # Partial module name, not filename
+    )
+    @loginator.log( msg )
+
     arg_hash = {
-      :name => name,
+      :name => partial, # Module name, not test name -- two modules Partialed in the same
+                        # test file must not collide on one shared types header filename
       :c_module => c_module,
-      :output_path => output_path
+      :output_path => output_path,
+      :includes => includes,
+      :include_guard => include_guard
     }
 
     return @generator_partials.generate_types( **arg_hash )
   end
 
-  def generate_partial_interface(test:, partial:, function_declarations:, includes:, c_module:, input_filepath:, output_path:)
+  def generate_partial_interface(test:, partial:, function_declarations:, includes:, c_module:, input_filepath:, output_path:, include_guard: nil)
     msg = @reportinator.generate_module_progress(
       operation: "Generating Partial mockable interface for",
       module_name: test,
@@ -64,7 +80,8 @@ class Generator
       :function_declarations => function_declarations,
       :includes => includes,
       :c_module => c_module,
-      :output_path => output_path
+      :output_path => output_path,
+      :include_guard => include_guard
     }
 
     return @generator_partials.generate_interface( **arg_hash )
@@ -78,7 +95,8 @@ class Generator
       header_includes:,
       c_module:,
       input_filepath:,
-      output_path:
+      output_path:,
+      include_guard: nil
     )
 
     msg = @reportinator.generate_module_progress(
@@ -95,13 +113,14 @@ class Generator
       :source_includes => source_includes,
       :header_includes => header_includes,
       :c_module => c_module,
-      :output_path => output_path
+      :output_path => output_path,
+      :include_guard => include_guard
     }
 
     return @generator_partials.generate_implementation( **arg_hash )
   end
 
-  def generate_mock(context:, mock:, test:, input_filepath:, output_path:)
+  def generate_mock(context:, mock:, test:, input_filepath:, output_path:, folder: nil, overrides: {})
     arg_hash = {
       :header_file => input_filepath,
       :test => test,
@@ -120,7 +139,9 @@ class Generator
       #  - Make CMock thread-safe
 
       # Get default config created by Ceedling and customize it
-      config = @generator_mocks.build_configuration( output_path )
+      # CMock writes to its root plus `folder`. That folder always ends `output_path`.
+      mock_root = folder ? output_path.delete_suffix( File.join( '', folder ) ) : output_path
+      config = @generator_mocks.build_configuration( mock_root, overrides: overrides )
   
       # Generate mock
       msg = @reportinator.generate_module_progress(
@@ -131,7 +152,7 @@ class Generator
       @loginator.log( msg )
 
       cmock = @generator_mocks.manufacture( config )
-      cmock.setup_mocks( arg_hash[:header_file] )
+      cmock.setup_mocks( arg_hash[:header_file], folder )
     rescue StandardError => ex
       # Re-raise execption but decorate it with CMock to better identify it
       raise( ex, "CMock >> #{ex.message}", ex.backtrace )
@@ -186,6 +207,9 @@ class Generator
     end
   end
 
+  # `compile_source` is the file actually handed to the compiler when it differs from
+  # `source`, such as an isolated copy. Plugins and logs still see `source`, and get
+  # `:compile_source` too so a command naming the copy can be traced to the original.
   def generate_object_file_c(
       tool:,
       module_name:,
@@ -197,7 +221,8 @@ class Generator
       defines:[],
       list:'',
       dependencies:'',
-      msg:nil
+      msg:nil,
+      compile_source:nil
     )
 
     shell_result = {}
@@ -212,6 +237,7 @@ class Generator
                  :defines => defines,
                  :list => list,
                  :dependencies => dependencies,
+                 :compile_source => compile_source,
                  :msg => String(msg)
                }
 
@@ -231,7 +257,7 @@ class Generator
         # Extra arguments
         arg_hash[:flags],
         # Argument replacement
-        arg_hash[:source],
+        compile_source || arg_hash[:source],
         arg_hash[:object],
         arg_hash[:list],
         arg_hash[:dependencies],
@@ -316,6 +342,20 @@ class Generator
     end
   end
 
+  # Windows' Installer Detection, part of User Account Control, demands administrator rights
+  # to run an executable whose name looks like an installer's. A manifest requesting the
+  # invoker's own rights turns it off, and is written only when missing or different.
+  def generate_test_executable_manifest(executable:, test_filepath:)
+    return unless @system_wrapper.windows?
+
+    manifest = "#{executable}.manifest"
+    unless @file_wrapper.exist?( manifest ) && @file_wrapper.read( manifest ) == TEST_EXECUTABLE_MANIFEST
+      @file_wrapper.write( manifest, TEST_EXECUTABLE_MANIFEST )
+    end
+
+    note_installer_name( File.basename( test_filepath ) )
+  end
+
   def generate_executable_file(tool, context, objects, flags, executable, map='', libraries=[], libpaths=[])
     shell_result = {}
     arg_hash = { :tool => tool,
@@ -358,76 +398,164 @@ class Generator
     end
   end
 
-  def generate_test_results(tool:, context:, test_name:, test_filepath:, executable:, result:)
-    arg_hash = {
-      :tool => tool,
-      :context => context,
-      :test_name => test_name,
-      :test_filepath => test_filepath,
-      :executable => executable,
-      :result_file => result,
-      :msg => @reportinator.generate_progress( "Running #{File.basename(executable)}" )
-    }
+  # `skipped: true` means the executable didn't need relinking (see
+  # TestBuildExecutor#stage_execute) -- its cached result from the last real
+  # run is reported instead of re-running it. Both fixture-execute hooks still
+  # fire either way, so plugins that accumulate per-run state from them (e.g.
+  # the live test summary) see this target on every run, not only when it's
+  # actually rebuilt. A damaged or missing cached result normally makes the
+  # fixture target stale first, since stage_execute records it as an output. If
+  # none exists here anyway, this falls back to a real run.
+  def generate_test_results(tool:, context:, test_name:, test_filepath:, executable:, result:, skipped: false)
+    arg_hash = fixture_arg_hash(
+      tool: tool, context: context, test_name: test_name, test_filepath: test_filepath, executable: executable, result_file: result
+    )
 
     @plugin_manager.pre_test_fixture_execute( arg_hash )
 
+    cached = skipped ? @generator_test_results.read_cached_results( result ) : nil
+    return report_cached_results( arg_hash, cached ) if cached
+
     @loginator.log( arg_hash[:msg] )
 
-    # Unity's exit code is equivalent to the number of failed tests.
-    # We tell @tool_executor not to fail out if there are failures
-    # so that we can run all tests and collect all results.
-    command = 
-      @tool_executor.build_command_line(
-        arg_hash[:tool],
-        # Extra arguments: Additional test case filters 
-        @test_runner_manager.collect_cmdline_args(),
-        # Argument replacement
-        arg_hash[:executable]
-      )
+    shell_result = run_test_fixture( arg_hash )
+    shell_result = handle_test_crash( arg_hash, shell_result ) if test_crash?( arg_hash, shell_result )
+
+    return write_test_results( arg_hash, shell_result )
+  end
+
+  # Flushes the whole-suite gdb health check accumulated across every crashing test
+  # executable's `do_gdb` retry in this run. Call once, after every test executable
+  # in the suite has finished executing and before final results reporting -- see
+  # `GeneratorTestResultsBacktrace#report_gdb_attach_health`. A no-op run (`:none` or
+  # `:simple` backtraces, or no crashes at all) never accumulates anything here.
+  def report_gdb_attach_health()
+    @backtrace.report_gdb_attach_health()
+  end
+
+  ### Private ###
+
+  private
+
+  def fixture_arg_hash(**fields)
+    return fields.merge( msg: @reportinator.generate_progress( "Running #{File.basename( fields[:executable] )}" ) )
+  end
+
+  def report_cached_results(arg_hash, cached)
+    arg_hash[:result_file]  = cached[:result_file]
+    arg_hash[:results]      = cached[:results]
+    arg_hash[:shell_result] = nil
+
+    @plugin_manager.post_test_fixture_execute( arg_hash )
+    return nil
+  end
+
+  # Unity's exit code is the number of failed tests, so the run is allowed to fail without
+  # an exception, and its results are analyzed apart from tool_executor. Test case filters
+  # follow the tool's own arguments, where a wrapping fixture tool runs the executable.
+  def run_test_fixture(arg_hash)
+    command = @tool_executor.build_command_line(
+      arg_hash[:tool], [], arg_hash[:executable], trailing: @test_runner_manager.collect_cmdline_args()
+    )
 
-    # Run the test executable itself
-    # We allow it to fail without an exception.
-    # We'll analyze its results apart from tool_executor
     command[:options][:boom] = false
-    shell_result = @tool_executor.exec( command )
-    filename = File.basename( test_filepath )
-
-    # Handle crashes
-    if @helper.test_crash?( filename, executable, shell_result )
-      @helper.log_test_results_crash(
-        executable,
-        shell_result,
-        @configurator.project_config_hash[:project_use_backtrace]
-      )
+    return @tool_executor.exec( command )
+  end
+
+  def test_crash?(arg_hash, shell_result)
+    return @helper.test_crash?( File.basename( arg_hash[:test_filepath] ), arg_hash[:executable], shell_result )
+  end
+
+  # Lists the crashed test's cases, filtered by any matchers the build task specified, and
+  # learns what it can about the crash as :project ↳ :use_backtrace allows. A crash a plugin
+  # explains needs no generic notice or backtrace advice.
+  def handle_test_crash(arg_hash, shell_result)
+    backtrace = backtrace_for( arg_hash[:tool] )
+    explanation = crash_explanation( arg_hash, shell_result, crash_notice: true )
+    log_crash( arg_hash[:executable], shell_result, backtrace, explanation )
+
+    test_cases = @test_context_extractor.lookup_test_cases( arg_hash[:test_filepath] )
+    test_cases = @generator_test_results.filter_test_cases( test_cases )
+
+    return crash_results( backtrace, arg_hash, shell_result, test_cases, explanation )
+  end
 
-      # Lookup test cases and filter based on any matchers specified for the build task
-      test_cases = @test_context_extractor.lookup_test_cases( test_filepath )
-      test_cases = @generator_test_results.filter_test_cases( test_cases )
-
-      case @configurator.project_config_hash[:project_use_backtrace]
-      # If we have the options and tools to learn more, dig into the details
-      when :gdb
-        shell_result =
-          @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: context )
-
-      # Simple test-case-by-test-case exercise
-      when :simple
-        shell_result =
-          @backtrace.do_simple( filename, executable, shell_result, test_cases, context: context )
-
-      else # :none
-        # Otherwise, call a crash a single failure so it shows up in the report
-        shell_result = @generator_test_results.create_crash_failure(
-          filename,
-          shell_result,
-          test_cases
-        )
-      end
+  def log_crash(executable, shell_result, backtrace, explanation)
+    return @helper.log_explained_crash( executable, explanation ) if explanation
+
+    # Either the fixture tool fell back from :gdb here, or startup found gdb unable to attach
+    gdb_unavailable = backtrace != @configurator.project_config_hash[:project_use_backtrace] ||
+                      @configurator.gdb_backtrace_state == :fell_back
+    @helper.log_test_results_crash( executable, shell_result, backtrace, gdb_unavailable: gdb_unavailable )
+  end
+
+  # A fixture tool that runs its own backtrace reruns can't run them under gdb
+  def backtrace_for(tool)
+    backtrace = @configurator.project_config_hash[:project_use_backtrace]
+    return backtrace unless backtrace == :gdb && tool.is_a?( Hash ) && tool[:backtrace_rerun]
+
+    note_gdb_fallback( tool )
+    return :simple
+  end
+
+  def note_gdb_fallback(tool)
+    @mutex.synchronize do
+      return if @gdb_fallback_noted
+
+      @gdb_fallback_noted = true
     end
-    
-    shell_result[:executable] = executable
+
+    @loginator.log( "Fixture tool `#{tool[:name]}` runs its own reruns, so :use_backtrace ➡️ :gdb falls back to :simple", Verbosity::NORMAL )
+  end
+
+  # The main run's explanation serves without backtraces; each :simple rerun has its own
+  def crash_results(backtrace, arg_hash, shell_result, test_cases, explanation)
+    filename, executable, context = File.basename( arg_hash[:test_filepath] ), arg_hash[:executable], arg_hash[:context]
+    explain = ->(result) { crash_message( crash_explanation( arg_hash, result ) ) }
+
+    case backtrace
+    when :gdb    then @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: context )
+    when :simple then @backtrace.do_simple( filename, executable, shell_result, test_cases, context: context, tool: arg_hash[:tool], explain: explain )
+    # A crash is otherwise reported as a single failure
+    else @generator_test_results.create_crash_failure( filename, shell_result, test_cases, message: crash_message( explanation ) || 'Test executable crashed' )
+    end
+  end
+
+  def note_installer_name(filename)
+    return unless filename.match?( WINDOWS_INSTALLER_KEYWORDS )
+
+    msg = "Test filename `#{filename}` 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.'
+    @loginator.log( msg, Verbosity::COMPLAIN )
+  end
+
+  # The cause of a crash, if a plugin recognizes it (e.g. a sanitizer's finding). Only the
+  # main run's explanation reaches a crash notice; a backtrace rerun's reaches its failure.
+  def crash_explanation(arg_hash, shell_result, crash_notice: false)
+    explaining = arg_hash.merge(
+      shell_result: shell_result, crash_notice: crash_notice, explanation: nil, explanation_details: nil, explanation_heading: nil
+    )
+    @plugin_manager.explain_test_crash( explaining )
+    return nil unless explaining[:explanation]
+
+    return { heading: explaining[:explanation_heading], cause: explaining[:explanation], details: Array( explaining[:explanation_details] ) }
+  end
+
+  # A test failure's message is a single line
+  def crash_message(explanation)
+    return nil unless explanation
+    return explanation[:cause] if explanation[:details].empty?
+
+    return "#{explanation[:cause]} (#{explanation[:details].join( '; ' )})"
+  end
+
+  # The caller already knows which test this run belongs to. Rediscovering it from the
+  # executable's bare basename would be wasteful and open to ambiguity.
+  def write_test_results(arg_hash, shell_result)
+    shell_result[:executable]  = arg_hash[:executable]
     shell_result[:result_file] = arg_hash[:result_file]
-    shell_result[:test_file] = @file_finder.find_test_file_from_filepath( arg_hash[:executable] )
+    shell_result[:test_file]   = arg_hash[:test_filepath]
     processed = @generator_test_results.process_and_write_results( shell_result )
 
     arg_hash[:result_file]  = processed[:result_file]
@@ -436,8 +564,7 @@ class Generator
     arg_hash[:shell_result] = shell_result
 
     @plugin_manager.post_test_fixture_execute( arg_hash )
-
-    shell_result
+    return shell_result
   end
 
 end

data/lib/ceedling/generators/generator_helper.rb

@@ -13,91 +13,138 @@ class GeneratorHelper
 
   constructor :loginator
 
+  # Every rule is checked, rather than stopping at the first, so each one that applies
+  # leaves its own debug log line
   def test_crash?(test_filename, executable, shell_result)
+    runner      = File.basename(executable)
+    stats_match = shell_result[:output].match( PATTERNS::TEST_STDOUT_STATISTICS )
+
+    return [
+      signal_death?( runner, shell_result[:status] ),
+      # Logged with the crash report itself, not here
+      stats_match.nil?,
+      clean_summary_contradicted?( runner, shell_result[:status], stats_match ),
+      bare_segfault?( runner, test_filename, shell_result[:stderr] )
+    ].any?
+  end
+
+  def log_test_results_crash(executable, shell_result, backtrace, gdb_unavailable: false)
     runner = File.basename(executable)
 
-    crash = false
-
-    # Any signal death is unconditionally a crash, whatever text made it out beforehand.
-    # Broadened from a SIGSEGV(11)-only check: a sanitizer's halt_on_error (UBSan, ASan)
-    # raises SIGABRT, not SIGSEGV, and there's no reason to trust a process that a
-    # signal actually killed regardless of which one. Applies to Unix-like systems
-    # including MSYS on Windows -- native (non-MSYS) Windows Ruby never reports
-    # `signaled?` true at all, so this check is inert there rather than wrong; the
-    # stats-footer and stderr checks below already carry Windows crash detection.
-    if shell_result[:status] && shell_result[:status].signaled?
-      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
-        "#{runner} process terminated by signal #{shell_result[:status].termsig}"
-      end
-      crash = true
-    end
+    notice  = "Test executable `#{runner}` seems to have crashed -- likely terminating early due to a bad code reference.\n"
+    notice += crash_output_notice( shell_result[:output] )
+    notice += "> Causes can include: bad memory access, stack overflow, heap error, or bad branch in source or test code.\n"
+    notice += backtrace_advice( backtrace, gdb_unavailable )
 
-    # No test results found in test executable output
-    stats_match = shell_result[:output].match( PATTERNS::TEST_STDOUT_STATISTICS )
-    if stats_match.nil?
-      # No debug logging here because we log this condition in the error log handling below
-      crash = true
-    end
+    @loginator.log( notice, Verbosity::ERRORS, LogLabels::CRASH )
+  end
 
-    # A clean summary (0 failures) is not trustworthy if the real process still exited
-    # nonzero afterward -- e.g. LeakSanitizer detecting a leak during teardown, after
-    # every test case already printed and Unity's own summary already looked clean.
-    # A nonzero exit consistent with Unity's own reported failures (its exit code
-    # convention is one per failed test case) is an ordinary failing run, not a crash.
-    if stats_match && shell_result[:status] && !shell_result[:status].success? &&
-       !shell_result[:status].signaled? && stats_match[2].to_i == 0
-      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
-        "#{runner} reported a clean summary but exited with real status #{shell_result[:status].exitstatus}"
-      end
-      crash = true
-    end
+  # A plugin's explanation names the cause, so no generic guidance follows it
+  def log_explained_crash(executable, explanation)
+    notice  = "Test executable `#{File.basename( executable )}` #{explanation[:heading] || 'crashed'}.\n"
+    notice += ([explanation[:cause]] + explanation[:details]).map { |line| "> #{line}\n" }.join
 
-    # Scan STDERR line by line for a segfault variant that is not attributed to the test file.
-    # A line starting with test_filename is a Unity-reported test-case result, not an OS crash.
-    # Checking each line individually avoids false negatives when attributed and bare segfault
-    # lines coexist in the same stderr output.
-    segfault_pattern = /Seg.*fault/i
-    bare_segfault = shell_result[:stderr].each_line.any? do |line|
-      line.match?(segfault_pattern) && !line.start_with?(test_filename)
-    end
+    @loginator.log( notice, Verbosity::ERRORS, LogLabels::CRASH )
+  end
 
-    if bare_segfault
-      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
-        "#{runner} STDERR reports segmentation fault"
-      end
-      crash = true
+  # A "redeclaration"/"redefinition"/"conflicting types"/"previous definition" family
+  # of compiler errors mentioning a header this test also mocks or Partializes is a
+  # strong signal that the real header's own content reached this compile a second,
+  # unmocked way -- substitution only ever replaces what a test's own #include
+  # directives name directly, so a module reaching the same real header through some
+  # other, unrelated #include chain slips past it entirely, and the genuine and
+  # substituted copies of the same declarations collide in the one compiled
+  # translation unit. Different compilers word this differently -- gcc's own
+  # "conflicting types for" and clang's "redefinition of"/"previous definition is
+  # here" are both real, observed wordings for the same underlying constraint
+  # violation, not a hypothetical spread to guard against.
+  #
+  # `mocked_headers` maps a real header's own basename to its real, resolved path --
+  # exactly the substitution knowledge a test's own mocks/Partials configuration
+  # already carries, cross-referenced here against whichever file paths the compiler's
+  # own error text happens to mention.
+  def explain_possible_mock_partial_collision(output:, mocked_headers:)
+    return nil if output.nil?
+    return nil unless output.match?(/redeclaration of|redefinition of|conflicting types|previous definition/i)
+
+    mentioned = output.scan( /([^\s"]+\.h):\d+:\d+/ ).flatten.uniq
+
+    culprit = mocked_headers.find do |basename, real_path|
+      mentioned.any? { |m| File.basename( m ) == basename && File.expand_path( m ) == File.expand_path( real_path ) }
     end
+    return nil if culprit.nil?
 
-    return crash
+    return collision_notice( *culprit )
   end
 
-  def log_test_results_crash(executable, shell_result, backtrace)
-    runner = File.basename(executable)
+  ### Private ###
 
-    notice = "Test executable `#{runner}` seems to have crashed -- likely terminating early due to a bad code reference.\n"
+  private
 
-    # Check for empty output
-    if (shell_result[:output].nil? or shell_result[:output].strip.empty?)
-      # Mirror style of generic tool_executor failure output
-      notice += "> Produced no output (including no final test result counts).\n"
+  # Any signal death is unconditionally a crash, whatever text made it out beforehand. A
+  # sanitizer that aborts raises SIGABRT, not SIGSEGV, and a process a signal killed is not
+  # to be trusted whichever signal it was. Native Windows Ruby never reports `signaled?`, so
+  # the check is inert there; the statistics and stderr checks carry Windows detection.
+  def signal_death?(runner, status)
+    return false unless status&.signaled?
 
-    # Check for no test results
-    elsif ((shell_result[:output] =~ PATTERNS::TEST_STDOUT_STATISTICS).nil?)
-      # Mirror style of generic tool_executor failure output
-      notice += "> Produced some output but contains no final test result counts.\n"
-    end
-    
-    notice += "> Causes can include: bad memory access, stack overflow, heap error, or bad branch in source or test code.\n"
+    @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) { "#{runner} process terminated by signal #{status.termsig}" }
+    return true
+  end
+
+  # A clean summary (0 failures) is not trustworthy if the process still exited nonzero
+  # afterward, e.g. a leak check at exit after every test case printed. A nonzero exit
+  # consistent with Unity's reported failures (its exit code is one per failed test case)
+  # is an ordinary failing run, not a crash.
+  def clean_summary_contradicted?(runner, status, stats_match)
+    return false if stats_match.nil? || status.nil? || status.success? || status.signaled?
+    return false unless stats_match[2].to_i == 0
 
-    # Incorporate knowledge of the backtrace setting into a recommendation
-    case backtrace
-    when :simple
-      notice += "> Consider configuring :project ↳ :use_backtrace to use the :gdb option to find the cause (see documentation).\n"
-    when :none
-      notice += "> Consider configuring :project ↳ :use_backtrace to help find the cause (see documentation).\n"
+    @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
+      "#{runner} reported a clean summary but exited with real status #{status.exitstatus}"
     end
+    return true
+  end
 
-    @loginator.log( notice, Verbosity::ERRORS, LogLabels::CRASH )
+  # A segfault line not starting with the test filename is an OS crash. A line starting
+  # with it is a Unity test-case result. Each line is checked on its own, so an attributed
+  # line beside a bare one still finds the bare one.
+  def bare_segfault?(runner, test_filename, stderr)
+    bare = stderr.each_line.any? { |line| line.match?( /Seg.*fault/i ) && !line.start_with?( test_filename ) }
+    return false unless bare
+
+    @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) { "#{runner} STDERR reports segmentation fault" }
+    return true
+  end
+
+  # Mirrors the style of the generic tool_executor failure output
+  def crash_output_notice(output)
+    return "> Produced no output (including no final test result counts).\n" if output.nil? || output.strip.empty?
+    return "> Produced some output but contains no final test result counts.\n" if (output =~ PATTERNS::TEST_STDOUT_STATISTICS).nil?
+
+    return ''
   end
-  
+
+  # No :gdb advice where :gdb can't be used
+  def backtrace_advice(backtrace, gdb_unavailable)
+    return "> Consider configuring :project ↳ :use_backtrace to help find the cause (see documentation).\n" if backtrace == :none
+    return '' unless backtrace == :simple && !gdb_unavailable
+
+    return "> Consider configuring :project ↳ :use_backtrace to use the :gdb option to find the cause (see documentation).\n"
+  end
+
+
+  def collision_notice(basename, real_path)
+    notice  = "This looks like '#{basename}' is mocked or Partialized for this test, but its " \
+              "real content ('#{real_path}') is also reaching compilation through a second " \
+              "unmocked #include chain.\n"
+    notice += "> The cause is most likely a transitive #include chain through an unrelated " \
+              "header brought about by C convention quirks in search paths and #include guards.\n"
+    notice += "> Consider investigating the #include chain and modifying your source or " \
+              "Partializing/mocking the problematic header (without necessarily using it) to " \
+              "break the transitive #include chain.\n"
+
+    return notice
+  end
+
 end

data/lib/ceedling/generators/generator_mocks.rb

@@ -15,26 +15,31 @@ class GeneratorMocks
     return CMock.new(config)
   end
 
-  def build_configuration( output_path )
+  def build_configuration( output_path, overrides: {} )
     config = @configurator.get_cmock_config
     config[:mock_path] = output_path
 
-    # Verbosity management for logging messages
+    # A project sets one overall verbosity; CMock's own scale is coarser (errors
+    # only, warnings and errors, normal, verbose), so this maps the finer scale
+    # down onto CMock's four levels, keeping messaging from both tools balanced
+    # rather than doubled up at every level. Middling verbosity levels settle
+    # on CMock's "warnings and errors" as a reasonable default.
     verbosity = @configurator.project_verbosity
 
-    # Default to errors and warnings only so we can customize messages inside Ceedling
     config[:verbosity] = 1
 
-    # Extreme ends of verbosity scale case handling
-    if    (verbosity == Verbosity::SILENT)
-      # CMock is silent
+    if    (verbosity <= Verbosity::ERRORS)
+      # CMock's quietest level -- errors only, since it has no true silent mode.
       config[:verbosity] = 0
-      
     elsif (verbosity == Verbosity::DEBUG)
-      # CMock max verbosity
       config[:verbosity] = 3
     end
 
+    # A caller with a reason to run this one mock through CMock differently than
+    # the project's own defaults hands in exactly the settings that differ; those
+    # win over whatever was computed above.
+    config.merge!( overrides )
+
     return config
   end