ceedling 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70deeef4f895489e967caec64bb020696e41fa327c83785eed4fa553a1c7b8bb
-  data.tar.gz: a3f48f487a174c6710601b693a44273542ca3934ae072d622994a19dd9d64884
+  metadata.gz: 8aabde4baeef95fad89e87cf3bd6226ffa3f10df9e54708270c82f237f3efe49
+  data.tar.gz: '08693e70f80deab8cb70f11677291f368a159df04b35f7a8d9fec8025522063a'
 SHA512:
-  metadata.gz: 8dcd78f2672ac8afcf375314ae458c0a734b000b0edae3aee34614492072aa2e53c5751ffbc15703b90e82527b1f740800a52231bf7922749df881c00aa3ed81
-  data.tar.gz: 29bb2ceace5a9f6d20fbf0d3546a708c1a07677aa558681c95ba3cf7c4991a487edf29e58226a084d169ee700a290c09695aed9f8a8d04923eb39aac9ba90449
+  metadata.gz: ab5f32d7896199850b29f6328c9e3fbaea63c0f5bf3dff665434ee0bd488992f971b18afd1bcf194e5c6f2ca66636cd72e38ab26fed3e74904cb374094f9c2b7
+  data.tar.gz: fab7cf5fe911d2dbc24bdb16add93551bfe8d9b7a668b888735ccfe199d04431707d5e01ec2d5ce345ee518db9b8f34376e16b92788ba1780e2ed20b8a32832c

data/GIT_COMMIT_SHA

@@ -1 +1 @@
-6f17bf8
+049a9d7

data/README.md

@@ -1,7 +1,7 @@
 Ceedling ![CI](https://github.com/ThrowTheSwitch/Ceedling/workflows/CI/badge.svg)
 ========
 
-**Ceedling 1.1.2** is the latest and greatest.
+**Ceedling 1.1.3** is the latest and greatest.
 
 See [_Release Notes_][release-notes], [_Changelog_](docs/Changelog.md), 
 [_Breaking Changes_][breaking-changes], and [_Known Issues_][known-issues].

data/assets/test_example_file_crash_sigsegv_with_param.c

@@ -0,0 +1,32 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include <signal.h>
+#include "unity.h"
+#include "example_file.h"
+
+
+void setUp(void) {}
+void tearDown(void) {}
+
+void test_add_numbers_will_fail(void) {
+  // Platform-independent way of forcing a crash
+  // NOTE: Avoid `nullptr` as it is a keyword in C23
+  uint32_t* a_null_pointer = (void*)0;
+  uint32_t i = *a_null_pointer;
+  TEST_ASSERT_EQUAL_INT(2, add_numbers(i,2));
+}
+
+// Regression coverage for issue #1185: a parameterized test defined after a
+// crashing test in the same file must still report its own real PASS/FAIL
+// results rather than being swept up as "crashed" alongside the actual crash.
+TEST_CASE(5, 3, 2)
+TEST_CASE(10, 4, 6)
+TEST_CASE(0, 0, 0)
+void test_difference_between_numbers_is_correct(int a, int b, int expected) {
+  TEST_ASSERT_EQUAL_INT(expected, difference_between_numbers(a, b));
+}

data/bin/actions_wrapper.rb

@@ -13,16 +13,17 @@ class ActionsWrapper
   include Thor::Base
   include Thor::Actions
 
-  JUNK_FILE_EXCLUDE_REGEX = 
+  JUNK_FILE_EXCLUDE_REGEX = /(\.DS_Store)|(thumbs\.db)/
 
   # Most important mixin method is Thor::Actions class method `source_root()` we call externally
 
   def _directory(src, *args)
-    # Insert exclusion of macOS and Windows preview junk files if an exclude pattern is not present
-    # Thor's use of args is an array of call arguments, some of which can be single key/value hash options
-    if !args.any? {|h| h.class != Hash ? false : !h[:exclude_pattern].nil?}
-      args << {:exclude_pattern => /(\.DS_Store)|(thumbs\.db)/}
-    end
+    # Build a single trailing options hash -- Thor's directory() only reads
+    # the last argument as options, so any caller-supplied hash (e.g.
+    # :force) and this default :exclude_pattern must live in the same hash.
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options[:exclude_pattern] ||= JUNK_FILE_EXCLUDE_REGEX
+    args << options
 
     directory( src, *args )
   end

data/docs/Changelog.md

@@ -10,6 +10,14 @@ This changelog is complemented by three other documents:
 
 ---
 
+# [1.1.3] — 2026-08-06
+
+## 💪 Fixed
+- [#1185](https://github.com/ThrowTheSwitch/Ceedling/issues/1185) Fixed / improved crash handling for parameterized Unity test cases.
+- [#1186](https://github.com/ThrowTheSwitch/Ceedling/issues/1186) Fixed `gcc` version lookup for the Gcov plugin running on Windows.
+- Ensure compilation symbols needed for Partials are injected when `:preprocess` defines are configured.
+- Fixed use of Thor’s Actions#directory to ensure a single options hash.
+
 # [1.1.2] — 2026-07-27
 
 ## 💪 Fixed

data/lib/ceedling/config/configurator.rb

@@ -88,10 +88,16 @@ class Configurator
       @loginator.log( "Reverted :cmock ↳ :treat_inlines to :exclude because this CMock feature is superseded by Partials.", Verbosity::COMPLAIN, LogLabels::NOTICE )
     end
 
-    # If partials enabled, inject partials name prefix symbol to all test compilation.
+    # If partials enabled, inject partials name prefix symbol to all test compilation
+    # and, if a project defines its own preprocess-scoped defines matcher, to
+    # preprocessing as well -- `:preprocess:` defines are looked up independently
+    # of `:test:` defines and only fall back to the latter when `:preprocess:`
+    # is absent entirely, so a project-defined `:preprocess:` matcher needs this
+    # symbol appended directly or Partials' own macro-based #includes break.
     # Handle both the simple list and matcher hash config formats.
     _partials_prefix_symbol = "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}"
     ConfigMatchinator.append_matcher_entries( config[:defines][:test], _partials_prefix_symbol )
+    ConfigMatchinator.append_matcher_entries( config[:defines][:preprocess], _partials_prefix_symbol )
   end
 
 

data/lib/ceedling/defaults.rb

@@ -69,7 +69,10 @@ DEFAULT_TEST_FIXTURE_SIMPLE_BACKTRACE_TOOL = {
   :name => 'default_test_fixture_simple_backtrace'.freeze,
   :optional => false.freeze,
   :arguments => [
-    '-n ${2}'.freeze # Exact test case name matching flag
+    # Test case matching flag and (quoted) value, fully composed by the caller as
+    # either `-n "<exact name>"` or `-f "<base name>"` -- see
+    # GeneratorTestResultsBacktrace#unity_filter_arg.
+    '${2}'.freeze
     ].freeze
   }
 
@@ -202,7 +205,10 @@ DEFAULT_TEST_BACKTRACE_GDB_TOOL = {
     "--command \"${1}\"".freeze, # Debug script file to run
     '--args'.freeze,
     '${2}'.freeze,               # Test executable
-    '-n ${3}'.freeze             # Exact test case name matching flag
+    # Test case matching flag and (quoted) value, fully composed by the caller as
+    # either `-n "<exact name>"` or `-f "<base name>"` -- see
+    # GeneratorTestResultsBacktrace#unity_filter_arg.
+    '${3}'.freeze
     ].freeze
   }
 

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -13,7 +13,8 @@ class GeneratorTestResultsBacktrace
     @RESULTS_COLLECTOR = Struct.new( :passed, :failed, :ignored, :output, keyword_init:true )
   end
 
-  # Re-runs each test case under gdb to identify which ones crashed and why.
+  # Re-runs each test case (or, for a parameterized test, each group of parameterized
+  # cases -- see `group_test_cases`) under gdb to identify which one(s) crashed and why.
   # Writes the full gdb transcript to a per-test-case log file and assembles a
   # terse crash label (signal + description, optional source line in backticks)
   # for each failing test case. Returns a modified shell_result with regenerated output.
@@ -28,54 +29,83 @@ class GeneratorTestResultsBacktrace
 
     test_name = File.basename( filename, '.*' )
 
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # 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: test_case[:test] )
-      @file_wrapper.mkdir( File.dirname( log_path ) )
-
-      # Build the test fixture to run with our test case of interest
+    # 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
       command = @tool_executor.build_command_line(
         @configurator.tools_test_backtrace_gdb, [],
         gdb_script_filepath,
         executable,
-        test_case[:test]
+        unity_filter_arg( group )
       )
       # Things are gonna go boom, so ignore booms to get output
       command[:options][:boom] = false
 
       crash_result = @tool_executor.exec( command )
 
-      # Sum execution time for each test case
+      # Sum execution time for each sub-process run
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
-      test_output = ''
+      unresolved = []
 
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
+      # Attribute each group member its own real result line, if Unity printed one
+      group.each do |test_case|
+        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
 
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
+        # 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
 
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
+          test_case_results[:failed]  += 1
+          test_case_results[:output] << $1
 
-      else # Crash failure case
-        test_case_results[:failed]  += 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.
+        else
+          unresolved << test_case
+        end
+      end
 
-        # Append full gdb output for this test case to the log
-        @file_wrapper.write( log_path, "=== #{test_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
+      next if unresolved.empty?
 
-        # Collect file_name and line in which crash occurred
-        matched = crash_result[:output].match( /#{test_case[:test]}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
+      # 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
+        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
@@ -86,7 +116,7 @@ class GeneratorTestResultsBacktrace
           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[:test], filename )
+          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).
@@ -94,7 +124,7 @@ class GeneratorTestResultsBacktrace
           crash_detail = source_line ? "#{NEWLINE_TOKEN}`#{source_line}`" : ''
 
           # Log path appears on its own encoded line so the results parser treats it separately
-          test_output =
+          test_case_results[:output] <<
             "#{filename}:#{line_number}:#{test_case[:test]}:FAIL: Test case crashed" \
             " >> #{signal_label}" \
             "#{crash_detail}" \
@@ -106,20 +136,18 @@ class GeneratorTestResultsBacktrace
           label = format_signal_label( crash_result[:output] )
 
           if !label.empty?
-            test_output =
+            test_case_results[:output] <<
               "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed" \
               " >> #{label}" \
               "#{NEWLINE_TOKEN}(#{log_path})"
           else
-            test_output =
+            test_case_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
-
-      test_case_results[:output] << test_output
     end
 
     # Reset shell result exit code and output
@@ -135,7 +163,8 @@ class GeneratorTestResultsBacktrace
     return shell_result
   end
 
-  # Re-runs each test case individually to determine which ones crashed.
+  # Re-runs each test case (or, for a parameterized test, each group of parameterized
+  # cases -- see `group_test_cases`) individually to determine which one(s) crashed.
   # For crash cases, captures any extra output from the test binary (e.g.
   # assertion messages on stderr) and includes it in the failure report.
   # Returns a modified shell_result with regenerated output.
@@ -146,50 +175,61 @@ class GeneratorTestResultsBacktrace
     # Reset time
     shell_result[:time] = 0
 
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # Build the test fixture to run with our test case of interest
+    # 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
       command = @tool_executor.build_command_line(
         @configurator.tools_test_fixture_simple_backtrace, [],
         executable,
-        test_case[:test]
+        unity_filter_arg( group )
       )
       # Things are gonna go boom, so ignore booms to get output
       command[:options][:boom] = false
 
       crash_result = @tool_executor.exec( command )
 
-      # Sum execution time for each test case
+      # Sum execution time for each sub-process run
       # Note: Running tests separately increases total execution time
       shell_result[:time] += crash_result[:time].to_f()
 
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
-
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
-
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
-
-      else # Crash failure case
-        test_case_results[:failed]  += 1
-
-        # Collect any non-result, non-blank lines (e.g. assertion messages on stderr)
-        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?
-      end
+      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
+      group.each do |test_case|
+        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
 
-      # Collect up real and stand-in test results output
-      test_case_results[:output] << test_output
+        # 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
+
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:FAIL(:.+)?\s*$)/
+          test_case_results[:failed]  += 1
+          test_case_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
+
+          if crashed
+            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"
+          else
+            crashed = true
+            # Collect any non-result, non-blank lines (e.g. assertion messages on stderr)
+            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
+          end
+        end
+      end
     end
 
     # Reset shell result exit code and output
@@ -208,6 +248,34 @@ class GeneratorTestResultsBacktrace
   ### Private ###
   private
 
+  # Groups test cases so each parameterized test's cases are isolated together as one
+  # sub-process run instead of one run per case. Unity's `-n`/`-f` command-line filter
+  # parser treats a comma as a separator between multiple OR'd filter clauses, so an
+  # exact filter can never match a parameterized case's runtime name once it has more
+  # than one argument (e.g. `name(5, 3, 2)`). Grouping by base name and matching each
+  # member's own result line out of the group's single shared sub-run output sidesteps
+  # that limitation entirely. Non-parameterized test cases are unaffected: each forms
+  # its own single-member group, isolated exactly as before.
+  def group_test_cases(test_cases)
+    test_cases.group_by { |test_case| test_case[:test].sub(/\(.*\)\z/, '') }.values
+  end
+
+  # Builds the Unity command-line filter argument for isolating one group (see
+  # `group_test_cases`). A non-parameterized (single-member, no-args) group is isolated
+  # with an exact-match filter as before. A parameterized group is isolated with a
+  # non-strict prefix filter on its shared base name -- the only reliable way to select
+  # such a group, since its members' runtime names contain commas.
+  def unity_filter_arg(group)
+    test_name = group.first[:test]
+
+    if test_name.include?('(')
+      base_name = test_name.sub(/\(.*\)\z/, '')
+      %(-f "#{base_name}")
+    else
+      %(-n "#{test_name}")
+    end
+  end
+
   # Builds a terse crash label from gdb output.
   # Rules:
   #   - Named signal explicitly in output → "[SIGNAL] Description"

data/lib/ceedling/generators/generator_test_runner.rb

@@ -62,8 +62,26 @@ class GeneratorTestRunner
     # Unity's runner generator `find_tests()` produces an array of hashes with the following keys...
     # { test:, args:, call:, params:, line_number: }
 
-    # For external use of test case names and line numbers, keep only those pieces of info
-    @test_cases = @test_cases_internal.map {|hash| hash.slice( :test, :line_number )}
+    # For external use, reduce down to test name, runtime C symbol, and line number.
+    # A parameterized test (`:args` populated) is expanded into one entry per TEST_CASE /
+    # TEST_RANGE / TEST_MATRIX row, since Unity's generated runner registers each invocation
+    # under its own name (matching `generate_test_runner.rb`'s `"#{test}(#{args})"` naming) and
+    # runs it through its own wrapper function (`runner_args<N>_<test>`). Collapsing these to a
+    # single bare-name entry breaks exact-match test case isolation (crash handling) for
+    # parameterized tests.
+    @test_cases = @test_cases_internal.flat_map do |hash|
+      if hash[:args].nil? || hash[:args].empty?
+        [ { test: hash[:test], symbol: hash[:test], line_number: hash[:line_number] } ]
+      else
+        hash[:args].each_with_index.map do |args, idx|
+          {
+            test:        "#{hash[:test]}(#{args})",
+            symbol:      "runner_args#{idx + 1}_#{hash[:test]}",
+            line_number: hash[:line_number]
+          }
+        end
+      end
+    end
   end
 
   def extract_test_cases(source_contents)

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.2'
+    GEM = '1.1.3'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/plugins/gcov/lib/gcov.rb

@@ -354,8 +354,8 @@ class Gcov < Plugin
 
     shell_result = @tool_executor.exec( command )
 
-    # First line of gcc --version: "gcc (...platform info...) major.minor.patch"
-    version_match = shell_result[:output].match(/^gcc\s+.*\s+(\d+)\.(\d+)\.\d+/)
+    # First line of gcc --version: "gcc[.exe] (...platform info...) major.minor.patch"
+    version_match = shell_result[:output].match(/^gcc(?:#{Regexp.escape(EXTENSION_WIN_EXE)})?\s+.*\s+(\d+)\.(\d+)\.\d+/)
 
     if version_match.nil? || version_match[1].nil? || version_match[2].nil?
       raise CeedlingException.new("Could not collect `gcc` version from its command line")

data/spec/support/system/system_context.rb

@@ -279,6 +279,21 @@ class SystemContext
       sections << stderr.strip
     end
 
+    # Loginator routes `Verbosity::DEBUG` messages (including the backtrace
+    # `log_debug_backtrace` emits for a caught exception) to stdout rather than
+    # stderr, and this method's stdout scan above only pulls lines containing
+    # the literal substrings 'ERROR'/'EXCEPTION' -- a bare backtrace line
+    # (file:line:in `method') contains neither, so without surfacing it here
+    # explicitly, the one piece of stdout most useful for diagnosing *why* a
+    # command failed would otherwise only ever reach the full raw-output log
+    # file, not this console-visible summary (what CI output actually shows).
+    label = 'Debug Backtrace ==>'
+    backtrace_block = extract_section(stdout, label)
+    unless backtrace_block.empty?
+      sections << ">> DEBUG BACKTRACE"
+      sections.concat(backtrace_block)
+    end
+
     label = 'FAILED TEST SUMMARY'
     failed_block = extract_section(stdout, label)
     unless failed_block.empty?

data/spec/system/deployment_as_gem_spec.rb

@@ -91,6 +91,7 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
     end
 
     describe "Backtrace with GDB" do
@@ -100,6 +101,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do

data/spec/system/deployment_as_vendor_spec.rb

@@ -94,6 +94,7 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
     end
 
     describe "Backtrace with GDB" do
@@ -103,6 +104,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do

data/spec/system/support/common_test_cases.rb

@@ -892,6 +892,96 @@ module CommonSystemTestCases
     end
   end
 
+  # Regression test for issue #1185: a parameterized test (TEST_CASE) defined after a
+  # crashing test in the same file must still report its own real PASS results instead
+  # of being swept up as "crashed" alongside the actual crash. Uses :use_backtrace => :simple
+  # (Ceedling's default), which is the mode in which the bug was reported.
+  def crash_simple_sigsegv_with_parameterized_test
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_crash_sigsegv_with_param.c"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :simple },
+          :unity   => { :use_param_tests => true }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).to eq(1) # Test should fail because of crash
+        expect(output).to match(/Unit test failures/)
+        # 1 crashing test + 3 parameterized cases
+        expect(output).to match(/TESTED:\s+4/)
+        expect(output).to match(/PASSED:\s+3/)
+        expect(output).to match(/FAILED:\s+1/)
+        expect(output).to match(/IGNORED:\s+0/)
+
+        result_file = './build/test/results/test_example_file_crash_sigsegv_with_param.fail'
+        expect(File.exist?(result_file)).to be(true)
+        results = YamlWrapper.new.load(result_file)
+
+        # Only the truly crashing test is reported as a failure/crash
+        expect(results[:failures].map { |f| f[:test] }).to eq(['test_add_numbers_will_fail'])
+        expect(results[:failures].first[:message]).to match(/Test case crashed/)
+
+        # Each parameterized case reports its own real (passing) result, by name, not a crash
+        expect(results[:successes].map { |s| s[:test] }).to contain_exactly(
+          'test_difference_between_numbers_is_correct(5, 3, 2)',
+          'test_difference_between_numbers_is_correct(10, 4, 6)',
+          'test_difference_between_numbers_is_correct(0, 0, 0)'
+        )
+      end
+    end
+  end
+
+  # Same regression coverage as `crash_simple_sigsegv_with_parameterized_test`, but for
+  # :use_backtrace => :gdb: confirms gdb-based isolation also correctly distinguishes the
+  # crashing test from the unrelated parameterized test, and still attributes the crash to
+  # the correct source line (exercising the gdb crash-frame symbol matching fix).
+  def crash_gdb_sigsegv_with_parameterized_test
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_crash_sigsegv_with_param.c"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :gdb },
+          :unity   => { :use_param_tests => true }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).to eq(1) # Test should fail because of crash
+        expect(output).to match(/Unit test failures/)
+        expect(output).to match(/TESTED:\s+4/)
+        expect(output).to match(/PASSED:\s+3/)
+        expect(output).to match(/FAILED:\s+1/)
+        expect(output).to match(/IGNORED:\s+0/)
+
+        result_file = './build/test/results/test_example_file_crash_sigsegv_with_param.fail'
+        expect(File.exist?(result_file)).to be(true)
+        results = YamlWrapper.new.load(result_file)
+
+        # Only the truly crashing test is reported as a failure/crash
+        expect(results[:failures].map { |f| f[:test] }).to eq(['test_add_numbers_will_fail'])
+        expect(results[:failures].first[:message]).to match(/Test case crashed/)
+        expect(results[:failures].first[:message]).to match(/SIGSEGV/i)
+
+        # Each parameterized case reports its own real (passing) result, by name, not a crash
+        expect(results[:successes].map { |s| s[:test] }).to contain_exactly(
+          'test_difference_between_numbers_is_correct(5, 3, 2)',
+          'test_difference_between_numbers_is_correct(10, 4, 6)',
+          'test_difference_between_numbers_is_correct(0, 0, 0)'
+        )
+
+        log_path = './build/logs/test/test_example_file_crash_sigsegv_with_param/test_add_numbers_will_fail.gdb.log'
+        expect(File.exist?(log_path)).to be(true)
+        expect(File.read(log_path)).to match(/SIGSEGV|Segmentation fault/i)
+      end
+    end
+  end
+
   def project_with_test_file_directly_including_source_file
     @c.with_context do
       Dir.chdir @proj_name do

data/spec/units/configurator_spec.rb

@@ -9,6 +9,7 @@ require 'spec_helper'
 require 'ceedling/config/configurator'
 require 'ceedling/ruby_expandinator'
 require 'ceedling/exceptions'
+require 'ceedling/constants'
 
 describe Configurator do
 
@@ -184,4 +185,48 @@ describe Configurator do
 
   end
 
+  describe "#set_partials_derived_config" do
+
+    def partials_config
+      { project: { use_partials: true }, defines: { test: ['TEST'] }, cmock: {} }
+    end
+
+    it "does nothing when :use_partials is disabled" do
+      config = partials_config
+      config[:project][:use_partials] = false
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:test] ).to eq( ['TEST'] )
+      expect( config[:defines] ).to_not have_key( :preprocess )
+    end
+
+    it "appends the partials prefix symbol to a simple :test: defines list" do
+      config = partials_config
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:test] ).to include( "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}" )
+    end
+
+    it "leaves :preprocess: defines untouched when the project does not define that section" do
+      config = partials_config
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines] ).to_not have_key( :preprocess )
+    end
+
+    it "appends the partials prefix symbol under the :* matcher when the project defines its own :preprocess: matcher hash" do
+      config = partials_config
+      config[:defines][:preprocess] = { 'TestSoilMoisture.c' => ['CEEDLING_DELTA_PROBE'] }
+
+      @configurator.set_partials_derived_config( config )
+
+      expect( config[:defines][:preprocess][:*] ).to include( "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}" )
+      expect( config[:defines][:preprocess]['TestSoilMoisture.c'] ).to eq( ['CEEDLING_DELTA_PROBE'] )
+    end
+
+  end
+
 end

data/spec/units/generators/generator_test_results_backtrace_spec.rb

@@ -65,6 +65,19 @@ GDB_NO_SIGNAL_OUTPUT = <<~GDB.freeze
   Inferior 1 (process 12345) exited with code 0139.
 GDB
 
+# Parameterized test crash (issue #1185): the crashing frame names the generated
+# wrapper function (`runner_args1_test_value_out_of_range_good`), not the human-facing
+# test name (`test_value_out_of_range_good(101, 1)`) that Unity reports at runtime.
+GDB_SIGSEGV_PARAM_OUTPUT = <<~GDB.freeze
+  [Thread debugging using libthread_db enabled]
+
+  Program received signal SIGSEGV, Segmentation fault.
+  0x00005618066ea1fb in runner_args1_test_value_out_of_range_good () at test/test_module_d.c:157
+  157	  int invalid = 1 / 0;
+  #0  0x00005618066ea1fb in runner_args1_test_value_out_of_range_good () at test/test_module_d.c:157
+  #1  0x00005618066eb4de in run_test (func=0x5618066ea1e7 <runner_args1_test_value_out_of_range_good>, name=0x5618066eb2e0 "test_value_out_of_range_good(101, 1)", line_num=157) at build/test/runners/test_module_d_runner.c:76
+GDB
+
 # Windows SIGSEGV — Thread N prefix, space-padded source line, DLL frames
 # Single-quoted heredoc: backslashes in Windows paths are literal, not escape sequences
 GDB_WINDOWS_SIGSEGV_OUTPUT = <<~'GDB'.freeze
@@ -153,7 +166,7 @@ describe GeneratorTestResultsBacktrace 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', line_number: 8 }] }
+    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')
@@ -194,7 +207,7 @@ describe GeneratorTestResultsBacktrace do
     end
 
     it 'handles a SIGSEGV crash — writes log, includes signal label, backtick source line, and log path' do
-      test_cases_sigsegv = [{ test: 'testCrash', line_number: 37 }]
+      test_cases_sigsegv = [{ test: 'testCrash', symbol: 'testCrash', line_number: 37 }]
       filename_sigsegv   = 'TestUsartModel.c'
 
       allow(@tool_executor).to receive(:exec)
@@ -219,8 +232,39 @@ describe GeneratorTestResultsBacktrace do
       expect(crash_line).to include('(/build/logs/test/TestUsartModel/testCrash.gdb.log)')
     end
 
-    it 'handles a SIGABRT crash from assert() — shows assertion text, no source line (issue #1038)' do
-      test_cases_assert = [{ test: 'test_asserting', line_number: 8 }]
+    it 'attributes a crash in a parameterized test to its wrapper symbol, not its display name' do
+      test_cases_param = [{
+        test:        'test_value_out_of_range_good(101, 1)',
+        symbol:      'runner_args1_test_value_out_of_range_good',
+        line_number: 157
+      }]
+      filename_param = 'test_module_d.c'
+
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: GDB_SIGSEGV_PARAM_OUTPUT, time: 0.5, exit_code: 139 })
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      expect(@file_wrapper).to receive(:write)
+        .with('/build/logs/test/test_module_d/test_value_out_of_range_good(101, 1).gdb.log', /=== test_value_out_of_range_good\(101, 1\) ===/, 'a')
+
+      @backtrace.do_gdb( filename_param, executable, shell_result, test_cases_param, context: :test )
+
+      crash_line = expected_output_lines.first
+      # The FAIL line reports the human-facing display name (with args)...
+      expect(crash_line).to start_with('test_module_d.c:157:test_value_out_of_range_good(101, 1):FAIL: Test case crashed')
+      # ...but the crash frame was still correctly located via the wrapper symbol.
+      expect(crash_line).to include('>> [SIGSEGV] Segmentation fault')
+      expect(crash_line).to include("#{NEWLINE_TOKEN}`int invalid = 1 / 0;`")
+      expect(crash_line).not_to include('failed to extract')
+    end
+
+    it 'handles a SIGABRT crash from assert() — shows assertion text, no source line' do
+      test_cases_assert = [{ test: 'test_asserting', symbol: 'test_asserting', line_number: 8 }]
 
       allow(@tool_executor).to receive(:exec)
         .and_return({ output: GDB_SIGABRT_ASSERT_OUTPUT, time: 0.3, exit_code: 134 })
@@ -460,7 +504,7 @@ describe GeneratorTestResultsBacktrace do
 
   describe '#do_gdb with brief Windows assert (no crash frame)' do
     let(:filename_assert)   { 'test_example_file_crash_assert.c' }
-    let(:test_cases_assert) { [{ test: 'test_add_numbers_triggers_assert', line_number: 20 }] }
+    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(:shell_result)      { { exit_code: 1, output: '', time: 0.0 } }
 

data/spec/units/generators/generator_test_runner_spec.rb

@@ -96,7 +96,7 @@ describe GeneratorTestRunner do
 
       runner = build_runner( test_file_contents: source )
 
-      expect( runner.test_cases ).to eq( [ { test: 'test_ShouldDoSomething', line_number: 2 } ] )
+      expect( runner.test_cases ).to eq( [ { test: 'test_ShouldDoSomething', symbol: 'test_ShouldDoSomething', line_number: 2 } ] )
     end
 
     it 'remaps line numbers back to the original file when preprocessed content is given' do
@@ -114,7 +114,31 @@ describe GeneratorTestRunner do
 
       runner = build_runner( test_file_contents: original, preprocessed_file_contents: preprocessed )
 
-      expect( runner.test_cases ).to eq( [ { test: 'test_ShouldDoSomething', line_number: 3 } ] )
+      expect( runner.test_cases ).to eq( [ { test: 'test_ShouldDoSomething', symbol: 'test_ShouldDoSomething', line_number: 3 } ] )
+    end
+
+    it 'expands a parameterized test into one entry per TEST_CASE, carrying the runtime name and wrapper symbol' do
+      source = <<~SOURCE
+        void setUp(void) {}
+        void tearDown(void) {}
+
+        TEST_CASE(101, 1)
+        TEST_CASE(-1, 1)
+        void test_value_out_of_range_good(int a, int expected) {}
+      SOURCE
+
+      runner = described_class.new(
+        config: { use_param_tests: true },
+        test_file_contents: source,
+        parsing_parcels: @parsing_parcels
+      )
+
+      expect( runner.test_cases ).to eq(
+        [
+          { test: 'test_value_out_of_range_good(101, 1)', symbol: 'runner_args1_test_value_out_of_range_good', line_number: 6 },
+          { test: 'test_value_out_of_range_good(-1, 1)',   symbol: 'runner_args2_test_value_out_of_range_good', line_number: 6 }
+        ]
+      )
     end
   end
 end

data/spec/units/test_context_extractor_spec.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ceedling
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Mark VanderVoord
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -184,6 +184,7 @@ files:
 - assets/test_example_file_boom.c
 - assets/test_example_file_crash_assert.c
 - assets/test_example_file_crash_sigsegv.c
+- assets/test_example_file_crash_sigsegv_with_param.c
 - assets/test_example_file_source_include.c
 - assets/test_example_file_success.c
 - assets/test_example_file_unity_printf.c