ceedling 1.1.7 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6379bc5002c0b3bbd2f670bffcbaf91afba5c0b5a8ea5438b626f758d8144f8d
-  data.tar.gz: 9b1dec28ef0fb39d47b41fb868522a1398f0b055f74e877a4afc64009fdb7ac3
+  metadata.gz: 28f18f89f99b7e81f68293c994fa85ff25532ca62bd250c2d1c7e351ec3ec7a0
+  data.tar.gz: 1252cbea2a5752315c65826f8068313450cf08d0ea63259e1e8a5d422588140c
 SHA512:
-  metadata.gz: d8db68c457e06b77007d1e954c4512a4c7e84abd13918546c31b5e05c4021e01e7ebafb5d3e85e0268d1742716e227d7860cdcc763f41f683c5d119f4841a998
-  data.tar.gz: 32ae8949567ae23bf7afff0deea71e66e06ea5dd6c56fcdde1dd561c5404020550ca9a65b11840f19ffde3a702fed80e73c2de03af0b8a1341490605a9b6b266
+  metadata.gz: 7aeb58a943b8df79fa31e12694a16019fba66cf798cc899eccb4d1e7b64d0b5fe09e5965f376791381cbc8c0e47a65c0563dbc5a00e1523714e813b8491a9896
+  data.tar.gz: e6cf0643c68cd8fa2c96b99de3e2e95ca276b27bf5ecb5cfa41ae9f1371ed55f3675ec5491d585b989629f2f89b0f16fc65f0586daa6ade065fbe903d9208087

data/GIT_COMMIT_SHA

@@ -1 +1 @@
-b1534f9
+2209dc2

data/README.md

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

data/docs/Changelog.md

@@ -10,6 +10,54 @@ This changelog is complemented by three other documents:
 
 ---
 
+# [1.1.9] — 2026-09-20
+
+## 💪 Fixed
+
+### Partials
+
+- [#1293](https://github.com/ThrowTheSwitch/Ceedling/issues/1293) Fixed a Partials-generated header occasionally redefining a type already declared by the real header it replaces, causing a `typedef redefinition with different types` compilation error. The triggering condition involved a source file whose real header was reachable both directly and through a macro-included intermediate file allowed by incomplete Partials include directive ordering.
+
+### Preprocessing
+
+- Fixed whitespace occasionally inserted by the underlying compiler's preprocessor around a `#` or `##` operator (e.g. `x ##y` becoming `x ## y`) being carried through verbatim into Partials-generated and reconstructed macro definitions. Extracted macro text is now normalized so preprocessing stringize and token-paste operators always sit directly against their operands, regardless of what a given toolchain's preprocessor happens to emit.
+
+## ⚠️ Changed
+
+- Updated Unity to latest version.
+
+---
+
+# [1.1.8] — 2026-09-10
+
+## 💪 Fixed
+
+- Fixed a crashed test case in a parameterized group occasionally being misattributed to a different, shorter-named test case in the same group whose name happened to be a substring of the one actually named in the crash backtrace.
+- Fixed a test case's line number occasionally being misattributed to an unrelated helper function whose name merely contained the test's name as a substring, cascading incorrect line numbers to every test case after it in the same file.
+
+### Partials
+
+- [#1262](https://github.com/ThrowTheSwitch/Ceedling/issues/1262) Fixed a Partials-generated header occasionally concatenating two adjacent `#define` lines in one line causing a stray '#' compilation error. The triggering condition involved a `//` or `/* */` comment containing an apostrophe or quote (e.g. `// Don't ...`) that disrupted string literal handling.
+
+### Preprocessing
+
+- [#1266](https://github.com/ThrowTheSwitch/Ceedling/issues/1266) Fixed a reconstructed header silently dropping any macro whose name or value merely contained the header's own include guard as a substring (e.g. guard `RTC_H` matching inside `RTC_HOUR_SECONDS`), causing undeclared-identifier compile errors.
+- [#1268](https://github.com/ThrowTheSwitch/Ceedling/issues/1268) Fixed a mockable header's `#include` losing the enums, structs, and function prototypes of a conditionally-included file when that `#include` was indented inside its `#ifdef` block, causing undeclared-identifier compile errors.
+
+### Gcov plugin
+
+- Fixed `:gcov ↳ :gcovr ↳ :decisions` reporting an incorrect minimum-version requirement; the version check (and docs) now correctly require `gcovr` 5.1 or higher.
+- Fixed `:gcov ↳ :gcovr ↳ :fail_under_line`/`:fail_under_branch`/`:fail_under_decision`/`:fail_under_function` silently accepting `0`, contradicting the documented 1–100 range; `0` is now rejected.
+- Fixed `:gcov ↳ :gcovr ↳ :object_directory` and `:source_encoding` values containing a space breaking the constructed `gcovr` command line; both are now quoted consistently with every other string-valued option.
+- Fixed a regex-metacharacter-injection risk (e.g. a literal `.`) in `:gcov ↳ :gcovr`'s and `:gcov ↳ :report_generator`'s auto-generated exclusion patterns in `:test_file_prefix`, `:mock_prefix`, or the build root path could silently over- or under-match files.
+- Fixed `:gcov ↳ :mcdc` triggering a `gcc --version` check (and a potential build-breaking exception for an older compiler) on every build in which a project enables the Gcov plugin, not only `gcov:` builds.
+- Fixed only the first of multiple simultaneously violated `:gcov ↳ :gcovr ↳ :fail_under_*` thresholds being reported when a build-breaking exception is raised; every violated threshold is now listed.
+- Fixed a latent mutation risk in `:gcov ↳ :report_generator` option handling that could accumulate stale exclusion patterns across repeated report-generation calls within a single run.
+- `:gcov ↳ :gcovr ↳ :branches`/`:sort_uncovered`/`:sort_percentage` now use `gcovr`'s renamed `--txt-metric branch`/`--sort uncovered-number`/`--sort uncovered-percent` flags on `gcovr` 7.0+, silencing `gcovr`'s deprecation warnings for those options. The pre-7.0 flag names are still used automatically with older `gcovr`.
+- Fixed the Gcov console summary silently producing no report and no log line at all for a Partial-implementation source whose `gcov` output couldn't be matched. It now logs the same "Found no coverage results" message the equivalent non-Partial case already did.
+
+---
+
 # [1.1.7] — 2026-09-03
 
 ## 💪 Fixed

data/docs/KnownIssues.md

@@ -20,6 +20,9 @@ Known issues are complemented by three other documents:
 1. While header file search paths are now customizable per executable, this currently only applies to the search paths the compiler uses. Distinguishing test files or header files of the same name in different directories for test runner and mock generation respectively continues to rely on educated guesses in Ceedling code.
 1. All header files needed for test compilation must be within the `:includes` path collection. Relative paths in include directives that extend outside the path collection will cause build problems.
 1. Any path for a C file specified with `TEST_SOURCE_FILE(...)` is in relation to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, many of your `TEST_SOURCE_FILE(...)` calls may need to be updated. A more flexible and dynamic approach to path handling will come in a future update.
+1. In certain combinations of conditional preprocessing blocks with dependent symbols defined in another file, Ceedling can silently fail to extract computed includes (e.g. `#include SOME_MACRO()`).
+1. User includes (`#include "path/user.h"`) from source C files lose their relative path when Partial and mock header files are generated from source. Compilation failures can result from certain uncommon cases involving headers of the same names in different directories and a source file including both such headers.
+1. The automatic vendor copying of Unity, CMock, and CException into a project's build directory can intermittently fail with a file/directory type error, most often under antivirus/EDR file locking, cloud-sync filter drivers, or two concurrent Ceedling invocations racing the same destination. Deleting `build/` (or reinstalling the gem) and rebuilding works around it.
 1. The Bullseye code coverage plugin has been temporarily disabled as of 1.0.0. The makers of Bullseye have generously provided a license for development, and the plugin will be available in the next minor release.
 
 ---

data/docs/mkdocs/plugins/gcov/gcovr.md

@@ -128,7 +128,7 @@ Report the decision coverage. For HTML, JSON, and the summary report.
 
 Implied automatically whenever `:fail_under_decision` is set.
 
-**Requires:** `gcovr` 6.0 or higher
+**Requires:** `gcovr` 5.1 or higher
 
 ---
 
@@ -163,21 +163,26 @@ Select the source file character encoding. (`gcovr --source-encoding`)
 ### `:branches`
 
 Report the branch coverage instead of the line coverage. Applies to the text
-report only. (`gcovr --branches`)
+report only. Uses `gcovr --txt-metric branch` on `gcovr` 7.0+ (`--branches` is
+deprecated as of 7.0, though still functional); `gcovr --branches` below it.
 
 ---
 
 ### `:sort_uncovered`
 
 Sort entries by increasing number of uncovered lines. Applies to text and HTML
-reports. (`gcovr --sort-uncovered`)
+reports. Uses `gcovr --sort uncovered-number` on `gcovr` 7.0+
+(`--sort-uncovered` is deprecated as of 7.0, though still functional);
+`gcovr --sort-uncovered` below it.
 
 ---
 
 ### `:sort_percentage`
 
 Sort entries by increasing percentage of uncovered lines. Applies to text and
-HTML reports. (`gcovr --sort-percentage`)
+HTML reports. Uses `gcovr --sort uncovered-percent` on `gcovr` 7.0+
+(`--sort-percentage` is deprecated as of 7.0, though still functional);
+`gcovr --sort-percentage` below it.
 
 ---
 

data/docs/mkdocs/reference/gcov-plugin.md

@@ -229,7 +229,7 @@ Report the decision coverage. For HTML, JSON, and the summary report.
 
 Implied automatically whenever `:fail_under_decision` is set.
 
-**Requires:** `gcovr` 6.0 or higher
+**Requires:** `gcovr` 5.1 or higher
 
 ---
 
@@ -262,21 +262,26 @@ Source file character encoding. (`gcovr --source-encoding`)
 ### `:branches`
 
 Report branch coverage instead of line coverage. Applies to text reports only.
-(`gcovr --branches`)
+Uses `gcovr --txt-metric branch` on `gcovr` 7.0+ (`--branches` is deprecated as
+of 7.0, though still functional); `gcovr --branches` below it.
 
 ---
 
 ### `:sort_uncovered`
 
 Sort report entries by increasing number of uncovered lines. Applies to text
-and HTML reports. (`gcovr --sort-uncovered`)
+and HTML reports. Uses `gcovr --sort uncovered-number` on `gcovr` 7.0+
+(`--sort-uncovered` is deprecated as of 7.0, though still functional);
+`gcovr --sort-uncovered` below it.
 
 ---
 
 ### `:sort_percentage`
 
 Sort report entries by increasing percentage of uncovered lines. Applies to
-text and HTML reports. (`gcovr --sort-percentage`)
+text and HTML reports. Uses `gcovr --sort uncovered-percent` on `gcovr` 7.0+
+(`--sort-percentage` is deprecated as of 7.0, though still functional);
+`gcovr --sort-percentage` below it.
 
 ---
 

data/lib/ceedling/c_extractor/c_extractor_declarations.rb

@@ -402,16 +402,17 @@ class CExtractorDeclarations
       return $1.strip
     end
 
-    # Find the name in the text and take everything before it (including pointer specifiers)
-    idx = text.rindex(name)
-    return nil if idx.nil?
-
-    type_part = text[0...idx]
-    # Include any pointer specifiers attached to the name
-    if text[idx..] =~ /^#{Regexp.escape(name)}/
-      # Look for * immediately before name (with optional space)
-      type_part = type_part.rstrip
-    end
+    # Find the name in the text and take everything before it (including pointer specifiers).
+    # A plain rindex(name) would find the last substring occurrence of `name` anywhere in
+    # text, even inside an unrelated longer identifier that merely ends with it (e.g. `name`
+    # "count" inside a type-side identifier like "recount") -- \b anchors this to a whole
+    # identifier occurrence. Greedy `.*` in a single match (not scan) naturally finds the
+    # rightmost such occurrence, since it consumes as much as possible before backtracking
+    # just enough to let the trailing \bname\b still match.
+    match = text.match(/\A(.*)\b#{Regexp.escape(name)}\b/m)
+    return nil if match.nil?
+
+    type_part = match[1]
     type_part.strip
   end
 

data/lib/ceedling/c_extractor/c_extractor_preprocessing.rb

@@ -241,9 +241,74 @@ class CExtractorPreprocessing
     text = scanner.scan(/#/)
 
     until scanner.eos?
-      text << (scanner.scan(/[^"'\\\n]*/) || '')
+      # '/' is excluded here (alongside the quote/backslash/newline characters
+      # already excluded) so a comment marker is never swallowed into this plain
+      # literal run -- it has to be seen and dispatched on its own below, before
+      # any '"' or "'" inside the comment's own text gets mistaken for the start
+      # of a string/char literal (see the // and /* branches for why that matters).
+      # '#' is excluded the same way, so a #/## operator is seen and dispatched on
+      # its own below rather than absorbed into this run along with whatever
+      # whitespace happens to surround it (see the ## and # branches for why).
+      text << (scanner.scan(/[^"'\\\n\/#]*/) || '')
+
+      if scanner.scan(%r{//})
+        # A trailing line comment (e.g. "// don't change this") can contain an
+        # apostrophe or quote that isn't a literal delimiter at all. Consumed the
+        # ordinary way, that stray quote would send skip_c_string hunting for a
+        # closing match, straight through this directive's own newline and into
+        # whatever follows -- silently merging the next #define into this one.
+        # Comment content is captured verbatim and never scanned for literals.
+        #
+        # A '\' immediately before the physical newline still splices lines here,
+        # same as everywhere else in a directive (line splicing is a translation
+        # phase that happens before comments are stripped), so the comment -- and
+        # the directive -- keeps going onto the next physical line rather than
+        # ending at that newline.
+        before = scanner.pos - 2
+        loop do
+          scanner.scan(/[^\\\n]*/)
+          break if scanner.eos?
+          break unless scanner.scan(/\\\n/) || scanner.scan(/\\/)
+        end
+        text << scanner.string[before...scanner.pos]
+
+      elsif scanner.scan(%r{/\*})
+        # A block comment can legitimately span physical lines without ending the
+        # directive (only an un-commented newline does that) -- its content, quotes
+        # included, is likewise never scanned for literals, only for its own close.
+        before = scanner.pos - 2
+        scanner.skip_until(%r{\*/}) || scanner.terminate
+        text << scanner.string[before...scanner.pos]
+
+      elsif scanner.scan(%r{/})
+        text << '/'
+
+      elsif scanner.scan(/##/)
+        # The C standard specifies ##'s token-paste semantics but not the exact
+        # whitespace a preprocessor emits when reconstructing macro text -- real
+        # toolchains can and do disagree here, and Ceedling regenerates this text
+        # into partials rather than promising byte-for-byte reproduction of that
+        # spacing. Discard whatever immediately follows the operator in the source,
+        # so its right-hand operand always glues on directly. The left side only
+        # trims when a word character (the operand actually being pasted) is
+        # immediately adjacent -- a lookbehind, not a blind rstrip -- so unrelated
+        # punctuation spacing that happens to precede the operator (e.g. the space
+        # after a macro argument's comma, or after the parameter list's closing
+        # paren when the replacement list itself starts with the operator) is left
+        # alone; that space was never the preprocessor-reconstruction artifact this
+        # is defending against. ## checked before bare '#' below so a real paste
+        # operator is never split into two stringize matches.
+        text.sub!(/(?<=\w)[ \t]+\z/, '')
+        scanner.scan(/[ \t]*/)
+        text << '##'
+
+      elsif scanner.scan(/#/)
+        # Same rationale as ## above, for the stringize operator.
+        text.sub!(/(?<=\w)[ \t]+\z/, '')
+        scanner.scan(/[ \t]*/)
+        text << '#'
 
-      if (ch = scanner.peek(1)) == '"' || ch == "'"
+      elsif (ch = scanner.peek(1)) == '"' || ch == "'"
         before = scanner.pos
         @c_extractor_code_text.skip_c_string(scanner, ch)
         text << scanner.string[before...scanner.pos]

data/lib/ceedling/file_path_utils.rb

@@ -124,6 +124,10 @@ class FilePathUtils
     pairs = paths.map { |p| [p, p.gsub('\\', '/').chomp('/')] }
 
     # Sort shallowest-first so ancestors are always encountered before their descendants.
+    # No tiebreaker for same-depth entries needed: Ruby's sort_by doesn't guarantee a
+    # stable order among ties, but two same-depth paths can never be each other's
+    # ancestor, so the ancestor-exclusion check below is correct regardless of which
+    # order same-depth ties come out in.
     pairs.sort_by! { |_, normalized| normalized.count('/') }
 
     kept = []

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -95,9 +95,11 @@ class GeneratorTestResultsBacktrace
         # 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).
+        # brief crash report with no frame information at all). \b anchors the symbol so a
+        # shorter unresolved symbol that's merely a suffix of a longer one actually named in
+        # the frame (e.g. "foo" vs "my_foo") can't steal the attribution.
         crashed_case = unresolved.find do |tc|
-          crash_result[:output].match?( /#{Regexp.escape(tc[:symbol])}\s*\(\)\sat/ )
+          crash_result[:output].match?( /\b#{Regexp.escape(tc[:symbol])}\s*\(\)\sat/ )
         end
         crashed_case ||= unresolved.first
 
@@ -458,7 +460,7 @@ class GeneratorTestResultsBacktrace
     output.lines.filter_map do |line|
       line = line.strip
       next if line.empty?
-      next if line =~ /^#{filename}.+:(PASS|FAIL|IGNORE)/
+      next if line =~ /^#{Regexp.escape(filename)}.+:(PASS|FAIL|IGNORE)/
       line
     end
   end

data/lib/ceedling/generators/generator_test_runner.rb

@@ -129,7 +129,11 @@ class GeneratorTestRunner
       break if remaining.empty?
 
       next_case = remaining.first
-      if (line =~ /#{next_case[:test]}/)
+      # Escaped (a raw test name can contain regex metacharacters) and \b-anchored on both
+      # sides so an unrelated line that merely contains this test's name as a substring --
+      # e.g. a helper function like `reset_test_ab_state()` sitting before `test_ab` itself
+      # -- can't steal its line number and cascade misalignment to every case after it.
+      if (line =~ /\b#{Regexp.escape(next_case[:test])}\b/)
         next_case[:line_number] = line_num
         remaining.shift
       end

data/lib/ceedling/includes/includes.rb

@@ -254,8 +254,15 @@ class Includes
     return _includes
   end
 
+  # Ruby's sort/sort_by family does not guarantee a stable sort -- the relative order
+  # of elements a comparator treats as equal (every UserInclude here, all mapping to
+  # the same "1") is free to come out differently across Ruby versions and platforms.
+  # partition sidesteps the question entirely: it's a simple filter, not a comparator
+  # sort, so each group's own original relative order is preserved by definition, on
+  # every Ruby version and platform, with nothing to be unstable about.
   def self.sort!(includes)
-    includes.sort_by! { |include| include.is_a?(SystemInclude) ? 0 : 1 }
+    system, other = includes.partition { |include| include.is_a?(SystemInclude) }
+    includes.replace(system + other)
     return includes
   end
 end

data/lib/ceedling/partials/partializer.rb

@@ -86,20 +86,17 @@ class Partializer
   def remap_implementation_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
+    # This module's own header include is spliced out in favor of the shared types
+    # header at its exact original list position -- see #splice_in_replacement.
+    _includes = splice_in_replacement(includes: _includes, name: name, replacement: types_header)
 
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
+    # Remove includes for every other partialized module (this module's own name was
+    # already handled above)
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + partialized_modules)
+      modules: (partials.keys - [name])
     )
 
-    # 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)
 
@@ -116,9 +113,19 @@ class Partializer
   def remap_implementation_source_includes(name:, includes:, partials:, test: nil)
     _includes = includes.clone()
 
-    # Add implementation header
-    _includes << UserInclude.new(
-      @file_path_utils.form_partial_implementation_header_filename(name)
+    # Splice the implementation header in at this module's own header's original list
+    # position, same rationale as #splice_in_replacement -- the generated
+    # implementation header carries the shared types header in correctly-ordered
+    # position internally, but that alone doesn't help if THIS file's own separate
+    # include list still reaches an unrelated header that transitively re-includes the
+    # real module header before the implementation header (and everything it carries)
+    # is ever reached. Appending it at the very end (after this file's own copy of every
+    # other real include) would put it after exactly that kind of transitive
+    # re-inclusion instead of before it.
+    _includes = splice_in_replacement(
+      includes: _includes,
+      name: name,
+      replacement: @file_path_utils.form_partial_implementation_header_filename(name)
     )
 
     mockable_modules = []
@@ -144,11 +151,12 @@ class Partializer
       end
     end
 
-    # Remove the original module header now that it's remapped to mockable interface
-    # Remove our own orginal name as well
+    # Remove the original headers of any OTHER modules now remapped to mockable
+    # interfaces above -- this module's own original header was already handled by
+    # the splice above.
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + mockable_modules)
+      modules: mockable_modules
     )
 
     # Remove any duplicates
@@ -167,20 +175,17 @@ class Partializer
   def remap_interface_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
     _includes = includes.clone()
 
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
+    # This module's own header include is spliced out in favor of the shared types
+    # header at its exact original list position -- see #splice_in_replacement.
+    _includes = splice_in_replacement(includes: _includes, name: name, replacement: types_header)
 
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
+    # Remove includes for every other partialized module (this module's own name was
+    # already handled above)
     _includes = remove_matching_includes(
       includes: _includes,
-      modules: ([name] + partialized_modules)
+      modules: (partials.keys - [name])
     )
 
-    # 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)
 
@@ -452,6 +457,46 @@ class Partializer
     )
   end
 
+  # Swaps `name`'s own header include for `replacement` at that same list position,
+  # instead of stripping it out and appending the replacement at the very end.
+  #
+  # Both call sites' generated replacements (the shared types header; the generated
+  # implementation header, which itself carries the types header) spoof the real
+  # header's own include guard (a top-of-file `#define <ORIGINAL_GUARD>`) so that if the
+  # real header is *also* reached a second way -- e.g. a transitively-included,
+  # differently-named header that itself does a genuine `#include` of this module's
+  # real header -- the real header's guard is already
+  # tripped and its content (a second, conflicting copy of the same typedefs/structs)
+  # never gets processed. That only works if the spoofing macro is defined *before*
+  # such a transitive re-inclusion is reached, not after. Appending at the very end put
+  # it after any such re-inclusion instead of before it. Keeping the replacement at the
+  # original header's own list position preserves everything the generated content
+  # depends on that came before it in the source's own working include order (e.g. a
+  # shared Types.h), while still landing ahead of anything transitively re-reaching the
+  # real header afterward.
+  def splice_in_replacement(includes:, name:, replacement:)
+    return remove_matching_includes(includes: includes, modules: [name]) unless replacement
+
+    replaced = false
+    spliced = includes.map do |include|
+      if !replaced && include.filename.ext().downcase() == name.downcase()
+        replaced = true
+        UserInclude.new(replacement)
+      else
+        include
+      end
+    end
+    # This module's own header wasn't in the includes list at all -- no original
+    # position to preserve, so fall back to appending.
+    spliced << UserInclude.new(replacement) unless replaced
+
+    # A duplicate/case-variant entry beyond the first match (e.g. both 'module.h' and
+    # 'MODULE.H' present) has no meaningful position of its own to preserve -- drop it
+    # like remove_matching_includes always has.
+    spliced = remove_matching_includes(includes: spliced, modules: [name])
+    spliced
+  end
+
   # Remove includes that match the given module names (case-insensitive)
   # Returns a new array with matching includes removed
   def remove_matching_includes(includes:, modules:)

data/lib/ceedling/preprocess/preprocessinator_line_marker_includes_extractor.rb

@@ -82,7 +82,12 @@ require 'set'
 
 # Parse GCC preprocessor output (from -fdirectives-only) to extract system include directives
 class PreprocessinatorLineMarkerIncludesExtractor
-  LINE_MARKER_REGEX = /^#\s+(\d+)\s+"([^"]+)"(?:\s+(\d+(?:\s+\d+)*))?$/ unless const_defined?(:LINE_MARKER_REGEX)
+  # Leading whitespace is tolerated (`^\s*`, not just `^`): GCC's -fdirectives-only output
+  # replaces a top-level #include with a line marker that inherits that #include's own
+  # original indentation (GH #1268) -- an indented `#include "x.h"` produces an indented
+  # `    # 1 "x.h" 1`, not the flush-left marker every OTHER marker GCC generates uses.
+  # Without this, such an include is silently missing from the extracted list entirely.
+  LINE_MARKER_REGEX = /^\s*#\s+(\d+)\s+"([^"]+)"(?:\s+(\d+(?:\s+\d+)*))?$/ unless const_defined?(:LINE_MARKER_REGEX)
 
   SYSTEM = :system  unless const_defined?(:SYSTEM)
   USER   = :user    unless const_defined?(:USER)

data/lib/ceedling/preprocess/preprocessinator_reconstructor.rb

@@ -236,8 +236,15 @@ class PreprocessinatorReconstructor
   def extract_macro_defs(file_contents, include_guard)
     macro_definitions = extract_multiline_directives( file_contents, 'define' )
 
-    # Remove an include guard if provided
-    macro_definitions.reject! {|macro| macro.include?( include_guard ) } if !include_guard.nil?
+    # Remove an include guard if provided. A plain substring test here would also reject
+    # any ordinary macro whose name or value happens to contain the guard string -- e.g.
+    # guard RTC_H matching inside RTC_HOUR_SECONDS' own name, or inside RTC_DAY_SECONDS'
+    # value, which references RTC_HOUR_SECONDS (GH #1266). Anchoring to "#define <guard>"
+    # followed by whitespace or end-of-line only matches the guard definition itself.
+    if !include_guard.nil?
+      include_guard_regex = /^\s*#\s*define\s+#{Regexp.escape(include_guard)}(?:\s|$)/
+      macro_definitions.reject! {|macro| macro =~ include_guard_regex }
+    end
 
     return macro_definitions
   end
@@ -271,10 +278,16 @@ class PreprocessinatorReconstructor
   def _scan_expansion_for_file(input, filepath, &block)
     # Expand filepath under inspection to ensure proper match
     extraction_filepath = File.expand_path( filepath )
-    # Preprocessor directive blocks generally take the form of '# <digits> <text> [optional digits]'
-    directive   = /^# \d+ \"/
+    # Preprocessor directive blocks generally take the form of '# <digits> <text> [optional digits]'.
+    # Leading whitespace is tolerated (`^\s*`, not just `^`): GCC's -fdirectives-only output
+    # replaces a top-level #include with a line marker that inherits that #include's own
+    # original indentation (GH #1268) -- an indented `#include "x.h"` produces an indented
+    # `    # 1 "x.h" 1`, not the flush-left marker every OTHER marker GCC generates uses.
+    # Failing to recognize such a marker here leaves `extract` stuck at whatever it already
+    # was instead of correctly toggling off, leaking the ignored file's content into output.
+    directive   = /^\s*# \d+ \"/
     # Line markers have the specific form of '# <digits> "path/filename.ext" [optional digits]' (see above)
-    line_marker = /^#\s(\d+)\s\"(.+)\"/
+    line_marker = /^\s*#\s(\d+)\s\"(.+)\"/
     # Boolean to ping pong between line-by-line extract/ignore
     extract = false
 

data/lib/version.rb

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

data/plugins/gcov/lib/console_reportinator.rb

@@ -169,6 +169,13 @@ class ConsoleReportinator < GcovReportinator
         section       = section.reject { |line| line.include?( File.basename( source,'.*') ) }
         report        = section.map { |line| report_name + ' | ' + line }.join('')
         @loginator.log( report )
+      else
+        # A Partial whose remapped name still doesn't match any File header in gcov's
+        # output -- without this, a Partial's unparseable coverage silently produces no
+        # report and no log at all, unlike the equivalent non-Partial case just below.
+        @loginator.lazy( Verbosity::COMPLAIN ) do
+          "Found no coverage results for #{test}::#{File.basename(source)}"
+        end
       end
 
     # Otherwise, found no coverage results

data/plugins/gcov/lib/gcov.rb

@@ -70,16 +70,12 @@ class Gcov < Plugin
 
     @mutex = Mutex.new()
 
-    # Validate MC/DC configuration against GCC version (only incurs gcc --version when :mcdc: TRUE)
-    if @project_config[:gcov_mcdc]
-      gcc_version = get_gcc_version()
-      if gcc_version.major < 14
-        raise CeedlingException.new(
-          ":gcov ↳ :mcdc ➡️ Modified condition/decision coverage requires GCC 14 or higher " \
-          "(found #{gcc_version.major}.#{gcc_version.minor})"
-        )
-      end
-    end
+    # See validate_mcdc_gcc_version! below for why this isn't checked eagerly here --
+    # setup() runs for every build this plugin is merely *enabled* for, not only real
+    # gcov: builds. Shelling out to `gcc --version` here would make GCC-version
+    # validation (and a build-breaking exception on too-old a GCC) fire even for builds
+    # that never touch :mcdc at all, e.g. plain `test:all`.
+    @mcdc_gcc_checked = false
   end
 
   # Called within class and also externally by plugin Rakefile
@@ -179,6 +175,8 @@ class Gcov < Plugin
 
       # Compile all non-assembly files with coverage; gcovr --exclude filters non-production files from reports
       if File.extname(source) != EXTENSION_ASSEMBLY
+        validate_mcdc_gcc_version!
+
         arg_hash[:tool] = TOOLS_GCOV_COMPILER
         arg_hash[:msg] = @reportinator.generate_module_progress(
           operation: "Compiling with coverage",
@@ -192,6 +190,8 @@ class Gcov < Plugin
 
   def pre_link_execute(arg_hash)
     if arg_hash[:context] == GCOV_SYM
+      validate_mcdc_gcc_version!
+
       @cli_gcov_task = true
       arg_hash[:tool] = TOOLS_GCOV_LINKER
       arg_hash[:flags] += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
@@ -364,6 +364,25 @@ class Gcov < Plugin
     return reportinators
   end
 
+  # Lazily validates :mcdc against the installed GCC version -- called from every
+  # gcov-context build hook that could otherwise emit -fcondition-coverage (compile,
+  # link), memoized so `gcc --version` runs at most once regardless of how many source
+  # files or hooks fire before it. See setup()'s own comment for why this isn't checked
+  # eagerly there.
+  def validate_mcdc_gcc_version!
+    return if @mcdc_gcc_checked
+    @mcdc_gcc_checked = true
+    return unless @project_config[:gcov_mcdc]
+
+    gcc_version = get_gcc_version()
+    if gcc_version.major < 14
+      raise CeedlingException.new(
+        ":gcov ↳ :mcdc ➡️ Modified condition/decision coverage requires GCC 14 or higher " \
+        "(found #{gcc_version.major}.#{gcc_version.minor})"
+      )
+    end
+  end
+
   def get_gcc_version()
     command = @tool_executor.build_command_line( TOOLS_GCOV_GCC_VERSION, [])