ceedling 1.1.3 → 1.1.4

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -7,10 +7,13 @@
 
 class GeneratorTestResultsBacktrace
 
-  constructor :configurator, :tool_executor, :generator_test_results, :file_path_utils, :file_wrapper
+  constructor :configurator, :tool_executor, :generator_test_results, :generator_helper,
+              :file_path_utils, :file_wrapper, :loginator
 
   def setup()
     @RESULTS_COLLECTOR = Struct.new( :passed, :failed, :ignored, :output, keyword_init:true )
+    # Alias, matching Generator's own convention for the same dependency.
+    @helper = @generator_helper
   end
 
   # Re-runs each test case (or, for a parameterized test, each group of parameterized
@@ -29,6 +32,13 @@ class GeneratorTestResultsBacktrace
 
     test_name = File.basename( filename, '.*' )
 
+    # True once some retry group has actually shown crash evidence of its own -- an
+    # unresolved member, or (below) a group whose real status contradicts a fully clean
+    # set of matches. If this stays false across every group, the whole diagnostic never
+    # reproduced or attributed the crash the main run already detected, and none of it
+    # can be trusted -- see the fallback after the loop.
+    any_group_crashed = false
+
     # Iterate on test cases, one sub-process run per group (see `group_test_cases`)
     group_test_cases( test_cases ).each do |group|
       # Build the test fixture to run with our test case (or parameterized group) of interest
@@ -47,6 +57,10 @@ class GeneratorTestResultsBacktrace
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
+      # Buffered separately from test_case_results and only merged in afterward, since
+      # the status check below can still discard every match here in favor of a crash
+      # attribution, once the whole group has been seen.
+      group_results = @RESULTS_COLLECTOR.new( passed:0, failed:0, ignored:0, output:[] )
       unresolved = []
 
       # Attribute each group member its own real result line, if Unity printed one
@@ -54,17 +68,17 @@ class GeneratorTestResultsBacktrace
         case crash_result[:output]
         # Success test case
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS\s*$)/
-          test_case_results[:passed]  += 1
-          test_case_results[:output] << $1
+          group_results[:passed]  += 1
+          group_results[:output] << $1
 
         # Ignored test case
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
-          test_case_results[:ignored] += 1
-          test_case_results[:output] << $1
+          group_results[:ignored] += 1
+          group_results[:output] << $1
 
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
-          test_case_results[:failed]  += 1
-          test_case_results[:output] << $1
+          group_results[:failed]  += 1
+          group_results[:output] << $1
 
         # No result line for this member -- either it crashed, or it never got to run
         # because an earlier member in this same group crashed. Resolved below.
@@ -73,81 +87,119 @@ class GeneratorTestResultsBacktrace
         end
       end
 
-      next if unresolved.empty?
-
-      # Prefer whichever unresolved member's own C symbol is actually named in the gdb
-      # backtrace (works regardless of position in the group); fall back to the first
-      # unresolved member if no member's symbol can be found in the transcript (e.g. a
-      # brief crash report with no frame information at all).
-      crashed_case = unresolved.find do |tc|
-        crash_result[:output].match?( /#{Regexp.escape(tc[:symbol])}\s*\(\)\sat/ )
-      end
-      crashed_case ||= unresolved.first
-
-      # Per-test-case log file: <log_path>/<context>/<test_name>/<test_case>.gdb.log
-      log_path = @file_path_utils.form_test_gdb_log( test_name, context: context, name: crashed_case[:test] )
-      @file_wrapper.mkdir( File.dirname( log_path ) )
-      @file_wrapper.write( log_path, "=== #{crashed_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
-
-      unresolved.each do |test_case|
-        test_case_results[:failed] += 1
-
-        if !test_case.equal?( crashed_case )
-          # An earlier case in this same parameterized group already crashed the
-          # process -- this member never got a chance to run.
-          test_case_results[:output] <<
-            "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
-            "Test case not run -- an earlier case in this parameterized test group crashed"
-          next
+      if !unresolved.empty?
+        # Prefer whichever unresolved member's own C symbol is actually named in the gdb
+        # backtrace (works regardless of position in the group); fall back to the first
+        # unresolved member if no member's symbol can be found in the transcript (e.g. a
+        # brief crash report with no frame information at all).
+        crashed_case = unresolved.find do |tc|
+          crash_result[:output].match?( /#{Regexp.escape(tc[:symbol])}\s*\(\)\sat/ )
         end
+        crashed_case ||= unresolved.first
 
-        # Collect file_name and line in which crash occurred.
-        # Match against the actual C symbol (`:symbol`), not the human-facing test name
-        # (`:test`): a parameterized test case crashes inside a generated wrapper function
-        # (`runner_args<N>_<test>`), not a function literally named `<test>(<args>)`.
-        matched = crash_result[:output].match( /#{Regexp.escape(test_case[:symbol])}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
-
-        # If we found an error report line containing `test_case() at filename.c:###` in `gdb` output
-        if matched
-          # Line number
-          line_number = matched[1]
-
-          # Build terse signal label: "[SIGNAL] Description"
-          signal_label = format_signal_label( crash_result[:output] )
-
-          # Extract the offending source line (nil for assertion crashes or when unavailable)
-          source_line = extract_source_line( crash_result[:output], test_case[:symbol], filename )
-
-          # Unity's test executable output is line oriented.
-          # Multi-line output is not possible (it looks like random `printf()` statements to the results parser).
-          # "Encode" newlines in multiline string to be handled by the test results parser.
-          crash_detail = source_line ? "#{NEWLINE_TOKEN}`#{source_line}`" : ''
-
-          # Log path appears on its own encoded line so the results parser treats it separately
-          test_case_results[:output] <<
-            "#{filename}:#{line_number}:#{test_case[:test]}:FAIL: Test case crashed" \
-            " >> #{signal_label}" \
-            "#{crash_detail}" \
-            "#{NEWLINE_TOKEN}(#{log_path})"
-
-        # Try to extract a useful label even when no crash location frame was found.
-        # A brief Windows assertion failure may report only the assertion text without frames.
-        else
-          label = format_signal_label( crash_result[:output] )
+        # Per-test-case log file: <log_path>/<context>/<test_name>/<test_case>.gdb.log
+        log_path = @file_path_utils.form_test_gdb_log( test_name, context: context, name: crashed_case[:test] )
+        @file_wrapper.mkdir( File.dirname( log_path ) )
+        @file_wrapper.write( log_path, "=== #{crashed_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
 
-          if !label.empty?
-            test_case_results[:output] <<
-              "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
-              " >> #{label}" \
-              "#{NEWLINE_TOKEN}(#{log_path})"
-          else
-            test_case_results[:output] <<
+        unresolved.each do |test_case|
+          group_results[:failed] += 1
+
+          if !test_case.equal?( crashed_case )
+            # An earlier case in this same parameterized group already crashed the
+            # process -- this member never got a chance to run.
+            group_results[:output] <<
               "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
-              "Test case crashed (failed to extract `gdb` report)" \
+              "Test case not run -- an earlier case in this parameterized test group crashed"
+            next
+          end
+
+          # Collect file_name and line in which crash occurred.
+          # Match against the actual C symbol (`:symbol`), not the human-facing test name
+          # (`:test`): a parameterized test case crashes inside a generated wrapper function
+          # (`runner_args<N>_<test>`), not a function literally named `<test>(<args>)`.
+          matched = crash_result[:output].match( /#{Regexp.escape(test_case[:symbol])}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
+
+          # If we found an error report line containing `test_case() at filename.c:###` in `gdb` output
+          if matched
+            # Line number
+            line_number = matched[1]
+
+            # Build terse signal label: "[SIGNAL] Description"
+            signal_label = format_signal_label( crash_result[:output] )
+
+            # Extract the offending source line (nil for assertion crashes or when unavailable)
+            source_line = extract_source_line( crash_result[:output], test_case[:symbol], filename )
+
+            # Unity's test executable output is line oriented.
+            # Multi-line output is not possible (it looks like random `printf()` statements to the results parser).
+            # "Encode" newlines in multiline string to be handled by the test results parser.
+            crash_detail = source_line ? "#{NEWLINE_TOKEN}`#{source_line}`" : ''
+
+            # Log path appears on its own encoded line so the results parser treats it separately
+            group_results[:output] <<
+              "#{filename}:#{line_number}:#{test_case[:test]}:FAIL: Test case crashed" \
+              " >> #{signal_label}" \
+              "#{crash_detail}" \
               "#{NEWLINE_TOKEN}(#{log_path})"
+
+          # Try to extract a useful label even when no crash location frame was found.
+          # A brief Windows assertion failure may report only the assertion text without frames.
+          else
+            label = format_signal_label( crash_result[:output] )
+
+            if !label.empty?
+              group_results[:output] <<
+                "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
+                " >> #{label}" \
+                "#{NEWLINE_TOKEN}(#{log_path})"
+            else
+              group_results[:output] <<
+                "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
+                "Test case crashed (failed to extract `gdb` report)" \
+                "#{NEWLINE_TOKEN}(#{log_path})"
+            end
           end
         end
       end
+
+      # Every member in this group resolved via a matched result line -- but gdb
+      # normally exits successfully after handling a crash regardless of what happened
+      # to the debuggee, so a clean-looking group here is a weaker signal than it is for
+      # `do_simple`. Still checked for the same reason: a diagnostic retry's own real
+      # status contradicting a fully clean set of matches is never trustworthy, whatever
+      # tool produced it.
+      if unresolved.empty? && @helper.test_crash?( filename, executable, crash_result )
+        group_results = @RESULTS_COLLECTOR.new(
+          passed: 0, ignored: 0, failed: group.size,
+          output: group.map { |test_case|
+            "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
+            " >> diagnostic retry's own exit status contradicts its reported clean result"
+          }
+        )
+        unresolved = group # non-empty now, marks this group as having shown crash evidence
+      end
+
+      any_group_crashed ||= !unresolved.empty?
+
+      test_case_results[:passed]  += group_results[:passed]
+      test_case_results[:ignored] += group_results[:ignored]
+      test_case_results[:failed]  += group_results[:failed]
+      test_case_results[:output].concat( group_results[:output] )
+    end
+
+    # No retry group, across the entire file, ever showed real crash evidence, yet this
+    # method only runs because the main run was already established as a crash. An
+    # all-clean diagnostic must never be allowed to overrule that -- fall back to the
+    # same whole-file crash-as-failure construction the :none backtrace setting uses.
+    unless any_group_crashed
+      @loginator.log(
+        "Diagnostic retry for `#{File.basename(executable)}` could not reproduce the crash " \
+        "already detected on the main run -- reporting the original crash rather than trusting " \
+        "an all-clear diagnostic that contradicts it.",
+        Verbosity::ERRORS, LogLabels::CRASH
+      )
+      return @generator_test_results.create_crash_failure( filename, shell_result, test_cases )
     end
 
     # Reset shell result exit code and output
@@ -175,6 +227,13 @@ class GeneratorTestResultsBacktrace
     # Reset time
     shell_result[:time] = 0
 
+    # True once some retry group has actually shown crash evidence of its own -- a
+    # member with no result line, or (below) a group whose real status contradicts a
+    # fully clean set of matches. If this stays false across every group, the whole
+    # diagnostic never reproduced or attributed the crash the main run already
+    # detected, and none of it can be trusted -- see the fallback after the loop.
+    any_group_crashed = false
+
     # Iterate on test cases, one sub-process run per group (see `group_test_cases`)
     group_test_cases( test_cases ).each do |group|
       # Build the test fixture to run with our test case (or parameterized group) of interest
@@ -192,6 +251,10 @@ class GeneratorTestResultsBacktrace
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
+      # Buffered separately from test_case_results and only merged in afterward, since
+      # the status check below can still discard every match here in favor of a crash
+      # attribution, once the whole group has been seen.
+      group_results = @RESULTS_COLLECTOR.new( passed:0, failed:0, ignored:0, output:[] )
       crashed = false # Has the actual crash in this group already been attributed?
 
       # Attribute each group member its own real result line, if Unity printed one
@@ -199,25 +262,25 @@ class GeneratorTestResultsBacktrace
         case crash_result[:output]
         # Success test case
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS\s*$)/
-          test_case_results[:passed]  += 1
-          test_case_results[:output] << $1
+          group_results[:passed]  += 1
+          group_results[:output] << $1
 
         # Ignored test case
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
-          test_case_results[:ignored] += 1
-          test_case_results[:output] << $1
+          group_results[:ignored] += 1
+          group_results[:output] << $1
 
         when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
-          test_case_results[:failed]  += 1
-          test_case_results[:output] << $1
+          group_results[:failed]  += 1
+          group_results[:output] << $1
 
         # No result line for this member -- either it crashed, or it never got to run
         # because an earlier member in this same group crashed.
         else
-          test_case_results[:failed] += 1
+          group_results[:failed] += 1
 
           if crashed
-            test_case_results[:output] <<
+            group_results[:output] <<
               "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: " \
               "Test case not run -- an earlier case in this parameterized test group crashed"
           else
@@ -226,10 +289,47 @@ class GeneratorTestResultsBacktrace
             extra = extract_simple_crash_output( crash_result[:output], filename )
             test_output = "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed"
             test_output += " >> #{extra.join(NEWLINE_TOKEN)}" unless extra.empty?
-            test_case_results[:output] << test_output
+            group_results[:output] << test_output
           end
         end
       end
+
+      # Every member in this group resolved via a matched result line -- but a diagnostic
+      # retry running through its own, separately-configured tool (e.g. without the main
+      # :test_fixture's sanitizer options) can complete cleanly and print a legitimate-
+      # looking PASS even when it isn't a trustworthy stand-in for what actually happened.
+      # The same real-status check the main run itself relies on applies here too.
+      if !crashed && @helper.test_crash?( filename, executable, crash_result )
+        crashed = true
+        group_results = @RESULTS_COLLECTOR.new(
+          passed: 0, ignored: 0, failed: group.size,
+          output: group.map { |test_case|
+            "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
+            " >> diagnostic retry's own exit status contradicts its reported clean result"
+          }
+        )
+      end
+
+      any_group_crashed ||= crashed
+
+      test_case_results[:passed]  += group_results[:passed]
+      test_case_results[:ignored] += group_results[:ignored]
+      test_case_results[:failed]  += group_results[:failed]
+      test_case_results[:output].concat( group_results[:output] )
+    end
+
+    # No retry group, across the entire file, ever showed real crash evidence, yet this
+    # method only runs because the main run was already established as a crash. An
+    # all-clean diagnostic must never be allowed to overrule that -- fall back to the
+    # same whole-file crash-as-failure construction the :none backtrace setting uses.
+    unless any_group_crashed
+      @loginator.log(
+        "Diagnostic retry for `#{File.basename(executable)}` could not reproduce the crash " \
+        "already detected on the main run -- reporting the original crash rather than trusting " \
+        "an all-clear diagnostic that contradicts it.",
+        Verbosity::ERRORS, LogLabels::CRASH
+      )
+      return @generator_test_results.create_crash_failure( filename, shell_result, test_cases )
     end
 
     # Reset shell result exit code and output

data/lib/ceedling/includes/includes.rb

@@ -32,10 +32,15 @@ class Includes
         else raise ArgumentError, "Unknown Include type: #{include.class}"
         end
 
-      {
+      hash = {
         'type' => type,
         'filepath' => include.filepath,
       }
+      # `include_path` is only ever meaningful on a reconciled SystemInclude, so it's
+      # written only when actually set -- a cached build's YAML stays uncluttered for
+      # the common, plain case.
+      hash['include_path'] = include.include_path if include.include_path
+      hash
     end
   end
 
@@ -63,11 +68,11 @@ class Includes
       
       case hash['type']
       when 'user'
-        UserInclude.new(hash['filepath'])
+        UserInclude.new(hash['filepath'], include_path: hash['include_path'])
       when 'mock'
         MockInclude.new(hash['filepath'])
       when 'system'
-        SystemInclude.new(hash['filepath'])
+        SystemInclude.new(hash['filepath'], include_path: hash['include_path'])
       else
         raise ArgumentError, "Invalid include type: #{hash['type']}. Must be 'user' or 'system'"
       end
@@ -153,6 +158,16 @@ class Includes
   # Compares bare includes against user and system includes and applies the following rules:
   # 1. Intersection of bare includes and system includes.
   # 2. Intersection of bare includes and user includes.
+  #
+  # A matched system include's `filepath` is its real, resolved location (possibly
+  # absolute), which is what identity and deduplication need but is wrong to render
+  # verbatim into a generated file. Each matched system include is therefore rebuilt
+  # carrying `include_path:` recovered from `bare` -- the original, as-written directive
+  # text -- via `best_bare_match`, so `<sys/stat.h>` renders as written instead of
+  # collapsing to `<stat.h>`. User includes are left untouched; unlike a system header's
+  # `<...>` text, a quoted include's own bare-includes pass can be resolved by GCC's
+  # directory-relative search before reconciliation ever sees it, so `bare` isn't a
+  # reliable source of "the literal, as-written spelling" for a user include.
   def self.reconcile(bare:, user:, system:)
     # Validate input types
 
@@ -179,10 +194,15 @@ class Includes
     # Create set of bare include filenames for O(1) lookup
     bare_filenames = Set.new(bare.map(&:filename))
 
-    # Intersect system includes with bare includes based on filename.
-    # Keep system includes that have matching filenames in bare list.
+    # Intersect system includes with bare includes based on filename, then rebuild each
+    # matched system include carrying the original, as-written directive spelling
+    # recovered from bare via best_bare_match, since filepath alone (the real, resolved
+    # location) is wrong to render verbatim.
     system_includes = system.select do |include|
       bare_filenames.include?(include.filename)
+    end.map do |include|
+      original = best_bare_match(bare, include.filepath)
+      SystemInclude.new(include.filepath, include_path: original.filepath)
     end
 
     # Intersect user includes with bare includes based on filename.
@@ -196,6 +216,36 @@ class Includes
     return (system_includes + user_includes)
   end
 
+  # Two filepaths correspond if the shorter one's path segments equal the longer one's
+  # own trailing segments, exactly, in order -- checked without regard for which side is
+  # shorter, since either a bare entry or its candidate may be the one carrying less path.
+  def self.paths_correspond?(a, b)
+    segments_a = a.split(/[\\\/]/).reject(&:empty?)
+    segments_b = b.split(/[\\\/]/).reject(&:empty?)
+    shorter, longer = segments_a.length <= segments_b.length ? [segments_a, segments_b] : [segments_b, segments_a]
+    return longer.last(shorter.length) == shorter
+  end
+  private_class_method :paths_correspond?
+
+  # Finds the bare entry that best identifies a resolved system include's original,
+  # as-written spelling. A bare entry carries no information about whether its own
+  # #include was quoted or bracketed, so a project's own same-named quoted include
+  # (`#include "stat.h"`) can sit in `bare` right alongside a system one
+  # (`#include <sys/stat.h>`). Preferring the *longest* path correspondence, rather than
+  # merely the first one found, keeps a short, unrelated bare entry -- which trivially
+  # "corresponds" to any longer resolved path ending in the same filename -- from
+  # shadowing the correct, more specific entry. Falls back to the longest same-filename
+  # candidate, even without path correspondence, only when the compiler's real
+  # search-path structure doesn't literally match the directive's own spelling (a
+  # symlinked or vendored include root, for instance).
+  def self.best_bare_match(bare, filepath)
+    candidates = bare.select { |bare_include| bare_include.filename == File.basename(filepath) }
+    corresponding = candidates.select { |bare_include| paths_correspond?(bare_include.filepath, filepath) }
+    pool = corresponding.empty? ? candidates : corresponding
+    return pool.max_by { |bare_include| bare_include.filepath.split(/[\\\/]/).reject(&:empty?).length }
+  end
+  private_class_method :best_bare_match
+
   # Sort list so system includes are at the beginning
   # (Best practice)
   def self.sort(includes)
@@ -216,6 +266,7 @@ class Include
   attr_reader :filepath
   attr_reader :filename
   attr_reader :path
+  attr_reader :include_path
 
   # Initialize an Include object from a C include statement or simple filepath.
   #
@@ -224,18 +275,21 @@ class Include
   #  - #include <stdio.h>
   #  - A quoted/bracketed filepath (e.g., '"header.h"' or <stdio.h>')
   #  - A plain filepath (e.g., 'path/to/header.h')
-  # @param use_path [Boolean] (default: false)
-  #  - If true, use the full filepath in the include directive
-  #  - If false, use only the filename
+  # @param include_path [String, nil] (default: nil)
+  #  - When set, this exact spelling is used in the include directive, taking
+  #    precedence over `filepath`/`filename`. This exists for a reconciled
+  #    SystemInclude, whose `filepath` is deliberately the header's real, resolved
+  #    location (needed elsewhere for identity -- see `Includes.sanitize!`) rather than
+  #    the original, as-written directive text a reconciled render needs.
   # @raise [ArgumentError] If the statement is empty or becomes empty after cleaning
-  def initialize(statement, use_path: false)
+  def initialize(statement, include_path: nil)
     @filepath = clean(statement)
 
     raise ArgumentError, "Empty include statement" if @filepath.empty?
 
     @filename = File.basename(@filepath)
     @path = File.dirname(@filepath)
-    @use_path = use_path
+    @include_path = clean(include_path) if include_path
   end
 
   # Method specialized by subclasses
@@ -294,7 +348,8 @@ class Include
 
   # Returns the configured entry to use in the include directive
   def include()
-    @use_path ? @filepath : @filename
+    return @include_path if @include_path
+    @filename
   end
 
   private

data/lib/ceedling/objects.yml

@@ -249,8 +249,10 @@ generator_test_results_backtrace:
      - configurator
      - tool_executor
      - generator_test_results
+     - generator_helper
      - file_path_utils
      - file_wrapper
+     - loginator
 
 generator_test_results_sanity_checker:
   compose:
@@ -312,6 +314,7 @@ preprocessinator_includes_handler:
     - tool_executor
     - parsing_parcels
     - file_wrapper
+    - file_path_utils
     - yaml_wrapper
     - loginator
     - reportinator
@@ -354,6 +357,8 @@ c_extractor:
     - c_extractor_functions
     - c_extractor_preprocessing
     - c_extractor_definitions
+    - configurator
+    - loginator
 
 partializer_config:
   compose:

data/lib/ceedling/partials/partializer.rb

@@ -83,7 +83,7 @@ class Partializer
   end
 
   # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
-  def remap_implementation_header_includes(name:, includes:, partials:, test: nil)
+  def remap_implementation_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
     # Get list of all partialized module names
@@ -96,6 +96,10 @@ class Partializer
       modules: ([name] + partialized_modules)
     )
 
+    # When this module has any typedefs or aggregate definitions, they live in a shared
+    # header generated once and included here rather than duplicated inline.
+    _includes << UserInclude.new(types_header) if types_header
+
     # Remove any duplicates
     Includes.sanitize!(_includes)
 
@@ -153,7 +157,7 @@ class Partializer
   end
 
   # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
-  def remap_interface_header_includes(name:, includes:, partials:, test: nil)
+  def remap_interface_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
     # Get list of all partialized module names
@@ -166,6 +170,10 @@ class Partializer
       modules: ([name] + partialized_modules)
     )
 
+    # When this module has any typedefs or aggregate definitions, they live in a shared
+    # header generated once and included here rather than duplicated inline.
+    _includes << UserInclude.new(types_header) if types_header
+
     # Remove any duplicates
     Includes.sanitize!(_includes)
 
@@ -341,8 +349,15 @@ class Partializer
       Verbosity::DEBUG
     )
 
+    # A mock interface only ever needs a signature, never a body, so a declaration-only
+    # function (no body found anywhere in this module's merged content) is just as valid a
+    # candidate as one with a definition -- unlike extract_implementation_functions, which
+    # needs real code to inject and so stays definitions-only. A function named in both
+    # (declared in the header, defined in the paired source) is only counted once.
+    candidates = definitions + declarations.reject { |d| definitions.any? { |f| f.name == d.name } }
+
     # Build initial list by visibility; ACCUMULATE yields []
-    funcs = @helper.filter_and_transform_funcs(definitions, pf.type, :interface)
+    funcs = @helper.filter_and_transform_funcs(candidates, pf.type, :interface)
 
     # Additions: search definitions first, then declarations
     pf.additions.each do |name|

data/lib/ceedling/partials/partializer_utils.rb

@@ -47,9 +47,14 @@ class PartializerUtils
         code_block:      new_code_block
       )
     when :interface
+      # A signature sourced from a CFunctionDefinition never carries a trailing semicolon
+      # (it's followed by a body, not one), but a signature sourced from a
+      # CFunctionDeclaration always does (it's a bare prototype). Strip it here so
+      # callers can render "#{signature};" uniformly regardless of which kind of
+      # function this interface entry came from.
       Partials.manufacture_function_declaration(
         name: func.name,
-        signature: signature
+        signature: signature.sub(/;\s*\z/, '')
       )
     else
       PartializerRuntime.raise_on_option(output_type)