ceedling 1.1.6 → 1.1.8

data/spec/support/system/system_context.rb

@@ -235,8 +235,11 @@ class SystemContext
     # encoding regardless of their actual content, so any project source content the
     # subprocess echoes (verbose logging, compiler output, etc.) can make later regex
     # matching against this string raise. Sanitize once here, the same way Ceedling itself
-    # sanitizes file content it scans.
-    @raw_output       = (stdout + stderr).clean_encoding
+    # sanitizes file content it scans -- reused for both the raw output and the failure
+    # report below, since a real compiler's own diagnostic text (e.g. clang's curly-quoted
+    # identifiers) is exactly the kind of non-ASCII content this needs to survive too.
+    stdout, stderr    = stdout.clean_encoding, stderr.clean_encoding
+    @raw_output       = stdout + stderr
     @console_summary  = compose_failure_report(stdout, stderr)
 
     SystemTestOutput.new(@raw_output)
@@ -250,7 +253,8 @@ class SystemContext
 
     @last_cmd         = cmd
     @last_exit_status = status.exitstatus
-    @raw_output       = (stdout + stderr).clean_encoding
+    stdout, stderr    = stdout.clean_encoding, stderr.clean_encoding
+    @raw_output       = stdout + stderr
     @console_summary  = compose_failure_report(stdout, stderr)
 
     SystemTestOutput.new(@raw_output)

data/spec/system/deployment_as_gem_spec.rb

@@ -87,6 +87,8 @@ ceedling_system_tests do
 
     describe "Verbosity and output" do
       test_case :test_project_with_named_verbosity
+      test_case :test_project_with_warnings_verbosity_prints_overall_summary
+      test_case :test_project_with_errors_verbosity_prints_overall_summary_on_passing_run
       test_case :test_project_with_numerical_verbosity
       test_case :report_tests_raw_output_log_plugin
     end

data/spec/system/deployment_as_vendor_spec.rb

@@ -90,6 +90,8 @@ ceedling_system_tests do
 
     describe "Verbosity and output" do
       test_case :test_project_with_named_verbosity
+      test_case :test_project_with_warnings_verbosity_prints_overall_summary
+      test_case :test_project_with_errors_verbosity_prints_overall_summary_on_passing_run
       test_case :test_project_with_numerical_verbosity
       test_case :report_tests_raw_output_log_plugin
     end

data/spec/system/gcov_deployment_spec.rb

@@ -33,8 +33,11 @@ ceedling_system_tests do
         end
       end
 
+      test_case :project_with_gcov_enabled_test_all_does_not_require_gcovr
       test_case :project_with_gcov_success
       test_case :project_with_gcov_fail
+      test_case :project_with_gcov_fail_under_decision
+      test_case :project_with_gcov_fail_under_line_rejects_zero
       test_case :gcov_console_report_with_system_header
       test_case :gcov_console_report_with_partial
       # TODO: Restore these tests when the :abort_on_uncovered option is restored in the Gcov plugin

data/spec/system/support/common_test_cases.rb

@@ -201,6 +201,48 @@ module CommonSystemTestCases
     end
   end
 
+  # The Overall Test Summary must still print at :warnings verbosity
+  # (`--verbosity=warnings`, Verbosity::COMPLAIN) on an all-passing run, not just
+  # when verbosity is :normal or higher, or when a test fails.
+  def test_project_with_warnings_verbosity_prints_overall_summary
+    @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_success.c"), 'test/'
+
+        output = @c.ceedling_build_exec("--verbosity=warnings")
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to match(/OVERALL TEST SUMMARY/)
+        expect(output).to match(/TESTED:\s+\d/)
+        expect(output).to match(/PASSED:\s+\d/)
+        expect(output).to match(/FAILED:\s+\d/)
+        expect(output).to match(/IGNORED:\s+\d/)
+      end
+    end
+  end
+
+  # ERRORS is the true floor for the Overall Test Summary -- a build's own
+  # test results are core information, visible even at the most restrictive
+  # verbosity short of :silent, whether the run passed or failed.
+  def test_project_with_errors_verbosity_prints_overall_summary_on_passing_run
+    @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_success.c"), 'test/'
+
+        output = @c.ceedling_build_exec("--verbosity=errors")
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to match(/OVERALL TEST SUMMARY/)
+        expect(output).to match(/TESTED:\s+\d/)
+        expect(output).to match(/PASSED:\s+\d/)
+        expect(output).to match(/FAILED:\s+\d/)
+        expect(output).to match(/IGNORED:\s+\d/)
+      end
+    end
+  end
+
   def test_project_with_numerical_verbosity
     @c.with_context do
       Dir.chdir @proj_name do

data/spec/system/support/gcov_common_test_cases.rb

@@ -10,6 +10,38 @@ require_relative 'gcov_helpers'
 module GcovCommonTestCases
   include GcovHelpers
 
+  # #1252 -- Enabling the gcov plugin must not make gcovr a hard dependency of every
+  # build. Deliberately does NOT call prep_project_yml_for_coverage (which conditionally
+  # strips :utilities ➡️ gcovr when the host lacks a real gcovr) -- the point here is
+  # gcovr enabled in config but genuinely unreachable, reproducing #1252 regardless of
+  # what's actually installed on the machine running this spec.
+  def project_with_gcov_enabled_test_all_does_not_require_gcovr
+    @c.with_context do
+      Dir.chdir @proj_name do
+        @c.uncomment_project_yml_option_for_test("- gcov")
+        # Default :gcov ↳ :utilities already includes gcovr and :reports already
+        # includes HtmlBasic -- exactly the enabled-but-unused shape #1252 reported.
+        @c.merge_project_yml_for_test(
+          { :tools => { :gcov_gcovr_report => { :executable => 'nonexistent_gcovr_binary_for_1252_test' } } }
+        )
+        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_success.c"), 'test/'
+
+        # An ordinary test:all run must succeed -- it never needs gcovr at all.
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to_not match(/nonexistent_gcovr_binary_for_1252_test/)
+
+        # A real gcov: build still needs gcovr and must still fail loudly when it's missing --
+        # the fix defers gcovr's tool validation, it doesn't remove it.
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to_not eq(0)
+        expect(output).to match(/nonexistent_gcovr_binary_for_1252_test/)
+      end
+    end
+  end
+
   def project_with_gcov_success
     @c.with_context do
       Dir.chdir @proj_name do
@@ -46,6 +78,44 @@ module GcovCommonTestCases
     end
   end
 
+  # gcovr's own --fail-under-decision is a no-op without --decisions also present --
+  # Ceedling supplies --decisions automatically whenever :fail_under_decision is
+  # configured, so a passing run reports success instead of gcovr's own opaque
+  # "need also option --decision" CLI error.
+  def project_with_gcov_fail_under_decision
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+        @c.merge_project_yml_for_test( { :gcov => { :gcovr => { :fail_under_decision => 1 } } } )
+        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_success.c"), 'test/'
+
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0)
+        expect(output).to_not match(/need also option --decision/)
+      end
+    end
+  end
+
+  # :fail_under_* documents a 1-100 range; 0 was previously silently accepted as a
+  # threshold that could never actually fail (0% coverage is always >= 0).
+  def project_with_gcov_fail_under_line_rejects_zero
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+        @c.merge_project_yml_for_test( { :gcov => { :gcovr => { :fail_under_line => 0 } } } )
+        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_success.c"), 'test/'
+
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to_not eq(0)
+        expect(output).to match(/:fail_under_line.*must be an integer percentage/)
+      end
+    end
+  end
+
   # TODO: Restore this test when the :abort_on_uncovered option is restored in the Gcov plugin
   # def project_with_gcov_fail_because_of_uncovered_files
   #   @c.with_context do

data/spec/units/c_extractor/c_extractor_declarations_spec.rb

@@ -52,6 +52,22 @@ describe CExtractorDeclarations do
         expect(rest).to eq("")
       end
 
+      # #1266 follow-on: same unanchored-substring risk class as #1262/#1266. The type-side
+      # identifier "counter_t" itself contains "count" as a substring; a plain rindex(name)
+      # would still find the real trailing occurrence here (rindex searches right-to-left),
+      # but this pins down that the \b-anchored match extract_type now uses doesn't regress
+      # this ordinary case, where the type name happens to share a substring with the
+      # declared name.
+      it "extracts a variable whose type name contains the variable's own name as a substring" do
+        content = "counter_t count;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'count', type: 'counter_t', text: 'counter_t count;')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
       it "extracts simple char variable" do
         content = "char c;"
         success, variable, pos, rest = extract_variable.call(content)

data/spec/units/c_extractor/c_extractor_integration_spec.rb

@@ -565,6 +565,59 @@ describe CExtractor do
       expect( contents.variable_declarations.length ).to eq 0
     end
 
+    # #1262: Partials-generated headers occasionally concatenated two adjacent
+    # #define lines onto one physical line. Reconstructing the joined text
+    # from element_sequence (as generator_partials.rb does) rules the plain,
+    # comment-free case in or out formally, rather than by inspection of
+    # #_collect_directive alone. This shape -- three plain register-offset
+    # macros in a row, no comments -- is expected to reconstruct cleanly.
+    it "reconstructs three adjacent plain #define macros joined by newlines with no text lost between them" do
+      file_contents = <<~'CONTENTS'
+      #define START_ADDRESS 0x00
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect( contents.macro_definitions.length ).to eq 3
+      joined = contents.element_sequence.map(&:text).join("\n")
+      expect( joined ).to eq(
+        "#define START_ADDRESS 0x00\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+      )
+    end
+
+    # #1262's actual reported trigger: a trailing // comment on one #define containing
+    # an ordinary English contraction. The stray apostrophe used to be scanned as the
+    # start of a char literal, sending the directive scanner hunting for a closing
+    # match straight through this macro's own newline and into the next two #defines
+    # -- merging all three into one macro_definitions entry with no separating newline,
+    # which is exactly what later caused Partials-generated headers to concatenate two
+    # #define lines onto one physical line ("stray '#' in program").
+    it "reconstructs three adjacent #define macros when one has a trailing comment with an apostrophe" do
+      file_contents = <<~'CONTENTS'
+      #define START_ADDRESS 0x00 // don't change this
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect( contents.macro_definitions.length ).to eq 3
+      expect( contents.macro_definitions[0].text ).to eq "#define START_ADDRESS 0x00 // don't change this"
+      expect( contents.macro_definitions[1].text ).to eq "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)"
+      expect( contents.macro_definitions[2].text ).to eq "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+
+      joined = contents.element_sequence.map(&:text).join("\n")
+      expect( joined ).to eq(
+        "#define START_ADDRESS 0x00 // don't change this\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+      )
+    end
+
     it "should extract a function definition following a #define with an escaped character in a string literal (GH #1184)" do
       file_contents = <<~'CONTENTS'
       #include "world.h"

data/spec/units/c_extractor/c_extractor_preprocessing_spec.rb

@@ -336,6 +336,51 @@ describe CExtractorPreprocessing do
       expect(pos).to eq "#define FOO 1\n".length
     end
 
+    # --- Regression: GH #1262 — a trailing // comment's apostrophe/quote merges
+    # the next directive into this one ---
+    # A '\'' or '"' inside an ordinary // comment (e.g. an English contraction
+    # like "don't") is not a string/char literal delimiter. Scanned as one
+    # anyway, it sends skip_c_string hunting for a closing match straight through
+    # this directive's own newline and into whatever follows, silently merging
+    # the next #define's text (and losing the newline between them) into this one.
+
+    it "extracts a #define with a trailing // comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 // don't change this\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "does not consume a following #define after a // comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 // don't change this\n#define IDX 1\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, "#define START_ADDRESS 0x00 // don't change this"]
+      expect(pos).to eq "#define START_ADDRESS 0x00 // don't change this\n".length
+    end
+
+    it "does not consume a following #define after a // comment containing a double quote" do
+      input = %(#define LABEL "unbalanced) + %( quote in a comment: "\n#define IDX 1\n)
+      result, pos = try_directive(input)
+      expect(result[0]).to eq true
+      expect(result[1]).to start_with('#define LABEL')
+      expect(pos).to be < input.length
+      expect(input[pos..]).to eq "#define IDX 1\n"
+    end
+
+    it "extracts a #define with a trailing /* */ comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 /* don't change this */\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "carries a directive across physical lines when a // comment's own line ends in a backslash" do
+      input = "#define MACRO(x) \\\n  // comment continues \\\n  do_thing(x);\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
     it "leaves scanner position unchanged on failure" do
       scanner = StringScanner.new("int x;")
       scanner.pos = 0

data/spec/units/generators/generator_partials_spec.rb

@@ -397,6 +397,56 @@ describe GeneratorPartials do
 
       expect( buf.string ).to_not include("#define FOO 1")
     end
+
+    # #1262: two consecutive typedefs (no macro carry-forward involved at
+    # all) had no byte-exact adjacency coverage -- only the macro-before-
+    # typedef pending_macros path did.
+    it "emits two consecutive typedefs each on their own line" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      typedef_a = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
+      typedef_b = CExtractorTypes::CStatement.new(text: "typedef uint16_t Word;", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions: [typedef_a, typedef_b],
+        element_sequence: [typedef_a, typedef_b]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "typedef uint8_t Byte;\ntypedef uint16_t Word;\n" )
+    end
+
+    # #1262: same gap for two consecutive aggregate definitions.
+    it "emits two consecutive aggregate definitions each on their own line" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      aggregate_a = CExtractorTypes::CStatement.new(text: "struct Point { int x; int y; };", line_num: 1)
+      aggregate_b = CExtractorTypes::CStatement.new(text: "struct Color { int r; int g; int b; };", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        aggregate_definitions: [aggregate_a, aggregate_b],
+        element_sequence:      [aggregate_a, aggregate_b]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "struct Point { int x; int y; };\nstruct Color { int r; int g; int b; };\n" )
+    end
   end
 
   context "#generate_header (private method)" do
@@ -555,6 +605,54 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
+    # #1262: a header with several single-line macros in a row and nothing
+    # type-defining after them (so generate_types never runs at all, per its
+    # own empty-module guard) is the ordinary, ungoverned case -- every macro
+    # here goes through this inline CStatement branch, not generate_types'
+    # own carry-forward logic, which already had its own adjacency coverage.
+    it "emits three consecutive macros each on their own line, with nothing following them" do
+      file_contents = <<~CONTENTS
+      #ifndef __CEEDLING_GENERATED_REGS_H__
+      #define __CEEDLING_GENERATED_REGS_H__
+
+      #define START_ADDRESS 0x00
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+
+      #endif // __CEEDLING_GENERATED_REGS_H__
+
+      CONTENTS
+
+      c_module = make_module(
+        make_stmt(text: "#define START_ADDRESS 0x00", line_num: 1),
+        make_stmt(text: "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)", line_num: 2),
+        make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
+      )
+
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+      expect( buf.string.strip() ).to eq file_contents.strip()
+    end
+
+    # #1262 regression: the actual reported shape -- one macro's trailing // comment
+    # includes an apostrophe. Extraction is what previously merged the macros (see
+    # c_extractor specs); this confirms generate_header still emits each item's text,
+    # comment included, on its own line once extraction is correct.
+    it "emits each macro on its own line even when one has a trailing comment with an apostrophe (GH #1262)" do
+      c_module = make_module(
+        make_stmt(text: "#define START_ADDRESS 0x00 // don't change this", line_num: 1),
+        make_stmt(text: "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)", line_num: 2),
+        make_stmt(text: "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)", line_num: 3)
+      )
+
+      @generator.send(:generate_header, buf, 'regs', [], [], c_module, false)
+
+      expect( buf.string ).to include(
+        "#define START_ADDRESS 0x00 // don't change this\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)\n"
+      )
+    end
+
     it "should emit macro and variable statements inline while routing typedefs and aggregates to the shared types header" do
       # One item of each category that can appear in a generated Partial header:
       #   macro_definitions     → CStatement emitted as-is, inline

data/spec/units/generators/generator_test_results_backtrace_spec.rb

@@ -130,6 +130,7 @@ SIMPLE_ASSERT_CRASH_OUTPUT =
 SIMPLE_PASS_OUTPUT   = "test_lib.c:3:test_empty:PASS\n---------\n1 Tests 0 Failures 0 Ignored\nOK\n"
 SIMPLE_FAIL_OUTPUT   = "test_lib.c:8:test_bad:FAIL: Expected 1 Was 2\n---------\n1 Tests 1 Failures 0 Ignored\nFAIL\n"
 SIMPLE_IGNORE_OUTPUT = "test_lib.c:12:test_skip:IGNORE\n---------\n1 Tests 0 Failures 1 Ignored\nOK\n"
+SIMPLE_IGNORE_WITH_MESSAGE_OUTPUT = "test_lib.c:12:test_skip:IGNORE: Not yet implemented\n---------\n1 Tests 0 Failures 1 Ignored\nOK\n"
 
 
 describe GeneratorTestResultsBacktrace do
@@ -255,6 +256,31 @@ describe GeneratorTestResultsBacktrace do
       expect(expected_output_lines).to include('test_lib.c:9:test_asserting:FAIL: Expected 1 Was 2')
     end
 
+    # Ignored-crash false positive: a TEST_IGNORE_MESSAGE(...) test case carries a
+    # trailing message, same as FAIL. Before this fix, only FAIL tolerated one --
+    # a message-carrying IGNORE fell through to "unresolved" and was misreported
+    # as crash evidence (a second @file_wrapper.write, for a companion_case that
+    # never actually crashed).
+    it 'handles an IGNORE test case with a trailing message and does not write a log' do
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status },
+        { output: "test_lib.c:9:test_asserting:IGNORE: Not yet implemented\n---------\n1 Tests 0 Failures 1 Ignored\nOK\n",
+          time: 0.1, exit_code: 0, stderr: '', status: @ok_status }
+      )
+
+      expect(@file_wrapper).to receive(:write).once.with(%r{test_crashes_elsewhere}, anything, anything)
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      @backtrace.do_gdb( filename, executable, shell_result, [companion_case] + test_cases, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:9:test_asserting:IGNORE: Not yet implemented')
+    end
+
     it "does not trust a matched PASS line when the retry's own real status contradicts it" do
       # Regression test for issue #1198: a diagnostic retry can print a clean Unity
       # result line while its own real process outcome says otherwise.
@@ -353,6 +379,32 @@ describe GeneratorTestResultsBacktrace do
       expect(crash_line).not_to include('failed to extract')
     end
 
+    # #1266 follow-on: the same unanchored-substring risk class as #1262/#1266, here in the
+    # "prefer whichever unresolved member's own symbol is named in the backtrace" search --
+    # no \b before the escaped symbol, so a shorter unresolved symbol that's a suffix of a
+    # longer one actually named in the crash frame can false-match and steal the attribution.
+    it 'attributes a crash to the member whose symbol actually appears in the backtrace, not a shorter symbol that is merely its suffix' do
+      test_cases_suffix = [
+        { test: 'test_x(1)', symbol: 'foo',    line_number: 10 },
+        { test: 'test_x(2)', symbol: 'my_foo', line_number: 20 }
+      ]
+      filename_suffix = 'test_module.c'
+
+      crash_output = <<~GDB
+        Program received signal SIGSEGV, Segmentation fault.
+        0x00005618066ea1fb in my_foo () at test/test_module.c:42
+        #0  0x00005618066ea1fb in my_foo () at test/test_module.c:42
+      GDB
+
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: crash_output, time: 0.5, exit_code: 139, stderr: '', status: @ok_status })
+
+      expect(@file_wrapper).to receive(:write)
+        .with('/build/logs/test/test_module/test_x(2).gdb.log', /=== test_x\(2\) ===/, 'a')
+
+      @backtrace.do_gdb( filename_suffix, executable, shell_result, test_cases_suffix, context: :test )
+    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 }]
 
@@ -471,6 +523,31 @@ describe GeneratorTestResultsBacktrace do
       expect(expected_output_lines).to include('test_lib.c:12:test_skip:IGNORE')
     end
 
+    # Ignored-crash false positive: a TEST_IGNORE_MESSAGE(...) test case carries a
+    # trailing message, same as FAIL (handled just above). Before this fix, only FAIL
+    # tolerated one -- a message-carrying IGNORE fell through to the "no result line"
+    # branch and was misreported as a second crashed test case (test_skip, alongside
+    # the real crash attributed to test_crashes_elsewhere).
+    it 'handles an IGNORE test case with a trailing message' do
+      test_cases_ignore = [{ test: 'test_crashes_elsewhere', line_number: 20 }, { test: 'test_skip', line_number: 12 }]
+
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status },
+        { output: SIMPLE_IGNORE_WITH_MESSAGE_OUTPUT, time: 0.02, exit_code: 0, stderr: '', status: @ok_status }
+      )
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      @backtrace.do_simple( filename, executable, shell_result, test_cases_ignore, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:12:test_skip:IGNORE: Not yet implemented')
+      expect(expected_output_lines).to_not include(a_string_matching(/test_skip:FAIL/))
+    end
+
     it "does not trust a matched PASS line when the retry's own real status contradicts it" do
       # Regression test for issue #1198: a diagnostic retry can print a clean Unity
       # result line while its own real process outcome says otherwise.

data/spec/units/generators/generator_test_runner_spec.rb

@@ -86,6 +86,29 @@ describe GeneratorTestRunner do
 
       expect( test_cases.first[:line_number] ).to eq( 5 )
     end
+
+    # #1266 follow-on: the same unanchored-substring risk class as #1262/#1266. A static
+    # helper function between two test cases whose name merely contains a later test's
+    # name as a substring (here "test_ab" inside "reset_test_ab_state") must not steal
+    # that test's line number, and an unescaped test name must not be treated as a regex.
+    it 'does not false-match a test name against an unrelated line that merely contains it as a substring' do
+      source = <<~SOURCE
+        void test_a(void) {}
+        void reset_test_ab_state(void) {}
+        void test_ab(void) {}
+      SOURCE
+
+      runner = build_runner( test_file_contents: source, preprocessed_file_contents: source )
+      test_cases = [
+        { test: 'test_a',  line_number: 0 },
+        { test: 'test_ab', line_number: 0 }
+      ]
+
+      runner.send( :remap_line_numbers!, test_cases, source )
+
+      expect( test_cases[0][:line_number] ).to eq( 1 )
+      expect( test_cases[1][:line_number] ).to eq( 3 )
+    end
   end
 
   describe '#initialize / #test_cases' do

data/spec/units/plugin_reportinator_spec.rb

@@ -0,0 +1,38 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/constants'
+require 'ceedling/plugins/plugin_reportinator'
+
+describe PluginReportinator do
+  before(:each) do
+    @plugin_reportinator_helper = double('plugin_reportinator_helper')
+    @plugin_manager             = double('plugin_manager')
+    @reportinator                = double('reportinator')
+    @loginator                      = double('loginator')
+
+    @reportinator_plugin = described_class.new(
+      {
+        :plugin_reportinator_helper => @plugin_reportinator_helper,
+        :plugin_manager             => @plugin_manager,
+        :reportinator               => @reportinator,
+        :loginator                  => @loginator
+      }
+    )
+  end
+
+  # A build's own test results -- pass or fail -- are core information a user
+  # silencing routine build chatter still wants to see, so every plugin that
+  # prints post-build test results (report_tests_stdout_plugin, gcov, valgrind)
+  # shares this one answer instead of each deciding independently.
+  describe '#test_results_floor_verbosity' do
+    it 'is ERRORS' do
+      expect( @reportinator_plugin.test_results_floor_verbosity ).to eq( Verbosity::ERRORS )
+    end
+  end
+end