ceedling 1.1.5 → 1.1.7

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

@@ -4,55 +4,137 @@ The `ReportGenerator` utility may be configured with the following configuration
 
 All generated reports are found in `<build root>/artifacts/gcov/ReportGenerator/`.
 
+## Example configuration
+
 ```yaml
 :gcov:
   :report_generator:
-    # Optional directory for storing persistent coverage information.
-    # Can be used in future reports to show coverage evolution.
-    :history_directory: <path>
+    :history_directory: build/artifacts/gcov/history
+    :file_filters: "-./vendor/*;-./build/*;-./test/*;+./src/*"
+    :verbosity: Warning
+    :tag: "release-1.4.0"
+    :num_parallel_threads: 4
+    :gcov_exclude:
+      - some_excluded_file
+    :custom_args:
+      - "-title:MyProject"
+```
+
+## Plugin configuration
+
+### `:history_directory`
+
+Optional directory for storing persistent coverage information. Can be used
+in future reports to show coverage evolution.
+
+---
+
+### `:plugins`
+
+Optional plugin files for custom reports or custom history storage (separated
+by semicolon).
+
+**Example:** `plugin.dll;*.dll`
+
+---
+
+### `:assembly_filters`
+
+Optional list of assemblies that should be included or excluded in the
+report (separated by semicolon). Exclusion filters take precedence over
+inclusion filters. Wildcards are allowed, but not regular expressions.
+
+**Example:** `+<included>;-<excluded>`
+
+---
+
+### `:class_filters`
+
+Optional list of classes that should be included or excluded in the report
+(separated by semicolon). Exclusion filters take precedence over inclusion
+filters. Wildcards are allowed, but not regular expressions.
+
+**Example:** `+<included>;-<excluded>`
+
+---
+
+### `:file_filters`
+
+Optional list of files that should be included or excluded in the report
+(separated by semicolon). Exclusion filters take precedence over inclusion
+filters. Wildcards are allowed, but not regular expressions. Ceedling places
+your own patterns first, ahead of the exclusions it generates automatically
+for test paths, the build root, and (when Partials are in use) Partial
+source files, so your patterns take precedence.
 
-    # Optional plugin files for custom reports or custom history storage (separated by semicolon).
-    :plugins: <plugin.dll>;<*.dll>
+**Example:** `"-./vendor/*;-./build/*;-./test/*;-./lib/*;+./src/*"`
 
-    # Optional list of assemblies that should be included or excluded in the report (separated by semicolon).
-    # Exclusion filters take precedence over inclusion filters.
-    # Wildcards are allowed, but not regular expressions.
-    :assembly_filters: +<included>;-<excluded>
+---
 
-    # Optional list of classes that should be included or excluded in the report (separated by semicolon).
-    # Exclusion filters take precedence over inclusion filters.
-    # Wildcards are allowed, but not regular expressions.
-    :class_filters: +<included>;-<excluded>
+### `:verbosity`
 
-    # Optional list of files that should be included or excluded in the report (separated by semicolon).
-    # Exclusion filters take precedence over inclusion filters.
-    # Wildcards are allowed, but not regular expressions.
-    # Example: "-./vendor/*;-./build/*;-./test/*;-./lib/*;+./src/*"
-    :file_filters: +<included>;-<excluded>
+The verbosity level of the log messages.
 
-    # The verbosity level of the log messages.
-    # Values: Verbose, Info, Warning, Error, Off (defaults to Warning)
-    :verbosity: <level>
+**Values:** `Verbose`, `Info`, `Warning`, `Error`, `Off`
 
-    # Optional tag or build version.
-    :tag: <tag>
+**Default:** `Warning`
 
-    # Optional list of one or more regular expressions to exclude gcov notes files that match these filters.
+---
+
+### `:tag`
+
+Optional tag or build version.
+
+---
+
+### `:gcov_exclude`
+
+Optional list of one or more regular expressions to exclude gcov notes
+(`.gcno`) files that match these filters from coverage processing — these
+files are never run through `gcov` at all. A trailing `.gcov` or `.gcno`
+suffix on a pattern is stripped automatically, so either form works.
+
+```yaml
+:gcov:
+  :report_generator:
     :gcov_exclude:
       - <regex>
       - ...
+```
+
+**Default:** `[]`
 
-    # Optionally set the number of threads to use in parallel. Defaults to 1.
-    :threads: <count>
+---
 
-    # Optional list of one or more command line arguments to pass to Report Generator.
-    # Useful for configuring Risk Hotspots and Other Settings.
-    # https://github.com/danielpalme/ReportGenerator/wiki/Settings
-    # Note: This can be accomplished with Ceedling's tool configuration options outside of plugin 
-    #       configuration but is supported here to collect configuration options in one place.
+### `:num_parallel_threads`
+
+Optionally set the number of threads ReportGenerator uses in parallel. Drives
+both of ReportGenerator's own `numberOfReportsParsedInParallel` and
+`numberOfReportsMergedInParallel` settings together.
+
+**Default:** unset (ReportGenerator's own default applies)
+
+---
+
+### `:custom_args`
+
+Optional list of one or more command line arguments to pass to Report
+Generator. Useful for configuring Risk Hotspots and other settings not
+covered by the options above. See the
+[ReportGenerator settings wiki](https://github.com/danielpalme/ReportGenerator/wiki/Settings).
+
+Note: This can be accomplished with Ceedling's tool configuration options
+outside of plugin configuration but is supported here to collect
+configuration options in one place.
+
+```yaml
+:gcov:
+  :report_generator:
     :custom_args:
       - <argument>
       - ...
 ```
 
+**Default:** `[]`
+
 <br/><br/>

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

@@ -213,8 +213,24 @@ Exit with status 4 if total branch coverage is below this percentage.
 Exit with status 8 if total decision coverage is below this percentage.
 (`gcovr --fail-under-decision`)
 
+`gcovr` treats `--fail-under-decision` as a no-op without `--decisions` also
+present — setting this option implies `:decisions` (below) automatically.
+
 **Values:** `1`–`100`
 
+**Requires:** `gcovr` 7.0 or higher
+
+---
+
+### `:decisions`
+
+Report the decision coverage. For HTML, JSON, and the summary report.
+(`gcovr --decisions`)
+
+Implied automatically whenever `:fail_under_decision` is set.
+
+**Requires:** `gcovr` 6.0 or higher
+
 ---
 
 ### `:fail_under_function`
@@ -552,11 +568,13 @@ are excluded from report generation.
 
 ---
 
-### `:threads`
+### `:num_parallel_threads`
 
-Number of parallel threads to use during report generation.
+Number of parallel threads to use during report generation. Drives both
+ReportGenerator's own `numberOfReportsParsedInParallel` and
+`numberOfReportsMergedInParallel` settings together.
 
-**Default:** `1`
+**Default:** unset (ReportGenerator's own default applies)
 
 ---
 

data/docs/mkdocs/snapshot/plugins/gcov/config/defaults.yml

@@ -27,7 +27,6 @@
 
   :report_generator:
     :verbosity: Warning           # Default verbosity
-    :collection_paths_source: []  # Explicitly defined as default empty array to simplify option validation code
     :custom_args: []              # Explicitly defined as default empty array to simplify option validation code
     :gcov_exclude: []             # Explicitly defined as default empty array to simplify option validation code
 ...

data/examples/wondrous_forest/src/SensorHal.h

@@ -16,4 +16,17 @@ bool   SensorHal_IsChannelReady(SensorChannel_t channel);
 void   SensorHal_StartConversion(SensorChannel_t channel);
 uint32 SensorHal_GetTimestampMs(void);
 
+/* Vendor-header-style static inline register accessor -- the same pattern that
+ * makes a real hardware header need Partial mocking instead of ordinary mocking,
+ * since there is no separate .c file to exclude from a test build and swap for a
+ * mock's .o at link time. The real body here stands in for what would otherwise
+ * be a direct, unsafe-off-target memory-mapped register read: it always returns
+ * the same obviously-wrong sentinel, so a test can tell whether this real body
+ * ran (Partial mocking failed to intercept the call) instead of its mock. */
+static inline uint16 SensorHal_RawStatusRegister(SensorChannel_t channel)
+{
+    (void)channel;
+    return 0xDEADu;
+}
+
 #endif /* SENSOR_HAL_H */

data/examples/wondrous_forest/src/TemperatureSensor.c

@@ -9,9 +9,10 @@
 #include "TemperatureSensor.h"
 #include "SensorHal.h"
 
-static float s_calibration_offset;
-static int32 s_last_milli_celsius;
-static bool  s_reading_valid;
+static float  s_calibration_offset;
+static int32  s_last_milli_celsius;
+static bool   s_reading_valid;
+static uint16 s_last_status_register;
 
 /* Linearized approximation: full-scale 4095 counts maps 0 C to 85 C. */
 static int32 TemperatureSensor__RawToMilliCelsius(uint16 raw_counts)
@@ -45,8 +46,9 @@ bool TemperatureSensor_Sample(void)
 
     if (!SensorHal_IsChannelReady(SENSOR_CHANNEL_TEMP)) { return false; }
 
-    raw     = SensorHal_ReadChannel(SENSOR_CHANNEL_TEMP);
-    milli_c = TemperatureSensor__RawToMilliCelsius(raw);
+    raw                    = SensorHal_ReadChannel(SENSOR_CHANNEL_TEMP);
+    s_last_status_register = SensorHal_RawStatusRegister(SENSOR_CHANNEL_TEMP);
+    milli_c                = TemperatureSensor__RawToMilliCelsius(raw);
     milli_c += (int32)(s_calibration_offset * 1000.0f);
 
     s_reading_valid      = TemperatureSensor__IsInRange(milli_c);
@@ -65,3 +67,8 @@ bool TemperatureSensor_IsValid(void)
 {
     return s_reading_valid;
 }
+
+uint16 TemperatureSensor_GetStatusRegister(void)
+{
+    return s_last_status_register;
+}

data/examples/wondrous_forest/src/TemperatureSensor.h

@@ -10,9 +10,10 @@
 
 #include "Types.h"
 
-void  TemperatureSensor_Init(float calibration_offset_celsius);
-bool  TemperatureSensor_Sample(void);
-int32 TemperatureSensor_GetMilliCelsius(void);
-bool  TemperatureSensor_IsValid(void);
+void   TemperatureSensor_Init(float calibration_offset_celsius);
+bool   TemperatureSensor_Sample(void);
+int32  TemperatureSensor_GetMilliCelsius(void);
+bool   TemperatureSensor_IsValid(void);
+uint16 TemperatureSensor_GetStatusRegister(void);
 
 #endif /* TEMPERATURE_SENSOR_H */

data/examples/wondrous_forest/test/TestTemperatureSensor.c

@@ -5,17 +5,25 @@
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
-/* Partials pattern: TEST_PARTIAL_ALL_MODULE
+/* Partials pattern: TEST_PARTIAL_ALL_MODULE + MOCK_PARTIAL_ALL_MODULE
  * Tests both public functions AND the private static helpers
  * TemperatureSensor__RawToMilliCelsius() and TemperatureSensor__IsInRange().
  * Also accesses the file-scoped static s_calibration_offset directly.
- * SensorHal is mocked traditionally since it has no private statics. */
+ * SensorHal is mocked via Partials (MOCK_PARTIAL_ALL_MODULE) rather than
+ * traditionally: SensorHal_RawStatusRegister() is a static inline function,
+ * which only Partial mocking (not ordinary CMock header mocking) can
+ * intercept -- there is no separate SensorHal.c definition for a static
+ * inline function to exclude from this test build and replace with a mock
+ * .o at link time, so the call must be redirected to the mock before that,
+ * at the #include level. Every existing SensorHal_*_Expect* call below
+ * keeps working unchanged either way, since Partial-mocked functions use
+ * the identical CMock expectation API as a traditionally mocked module. */
 
 #include "unity.h"
 #include "ceedling.h"
-#include "MockSensorHal.h"
 
 #include TEST_PARTIAL_ALL_MODULE(TemperatureSensor)
+#include MOCK_PARTIAL_ALL_MODULE(SensorHal)
 
 #include "Types.h"
 
@@ -78,6 +86,7 @@ void test_Sample_ReturnsTrueAndStoresReadingWhenReady(void)
     /* 1638 counts: (1638 * 85000) / 4095 ~= 34000 milli-C (34 C), in range */
     SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_TEMP, true);
     SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 1638u);
+    SensorHal_RawStatusRegister_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 0x1234u);
     SensorHal_StartConversion_Expect(SENSOR_CHANNEL_TEMP);
 
     TEST_ASSERT_TRUE(TemperatureSensor_Sample());
@@ -93,8 +102,28 @@ void test_CalibrationOffsetShiftsReading(void)
     /* 2048 counts ~= 42502 milli-C; with +1.0 C offset -> ~= 43502 */
     SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_TEMP, true);
     SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 2048u);
+    SensorHal_RawStatusRegister_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 0x1234u);
     SensorHal_StartConversion_Expect(SENSOR_CHANNEL_TEMP);
 
     TemperatureSensor_Sample();
     TEST_ASSERT_INT32_WITHIN(200, 43502, TemperatureSensor_GetMilliCelsius());
 }
+
+/* Regression test for #1215: a module partial-mocked via MOCK_PARTIAL_ALL_MODULE
+ * (as SensorHal is above) must have its calling module's real #include swapped for
+ * the generated mock interface header. Without that swap, SensorHal_RawStatusRegister()'s
+ * real static inline body -- unreachable through ordinary link-time mock substitution,
+ * since a static inline function has no separate object file to exclude -- compiles
+ * straight into this test build and always returns its 0xDEAD sentinel regardless of
+ * what's expected here, no matter what the mock is told to return. */
+void test_StatusRegisterReflectsMockedValueNotRealSentinel(void)
+{
+    SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_TEMP, true);
+    SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 1638u);
+    SensorHal_RawStatusRegister_ExpectAndReturn(SENSOR_CHANNEL_TEMP, 0x1234u);
+    SensorHal_StartConversion_Expect(SENSOR_CHANNEL_TEMP);
+
+    TemperatureSensor_Sample();
+
+    TEST_ASSERT_EQUAL_HEX16(0x1234u, TemperatureSensor_GetStatusRegister());
+}

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -66,13 +66,17 @@ class GeneratorTestResultsBacktrace
       # 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*$)/
+        # Success test case -- tolerates a trailing duration suffix (e.g. `PASS (12 ms)`,
+        # UNITY_INCLUDE_EXEC_TIME), matching the real format generator_test_results.rb's
+        # own parser already recognizes for it.
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS(\s\(.*ms\))?\s*$)/
           group_results[:passed]  += 1
           group_results[:output] << $1
 
-        # Ignored test case
-        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
+        # Ignored test case -- tolerates a trailing message (TEST_IGNORE_MESSAGE), same as
+        # FAIL below. Before this fix, a message-carrying ignore fell through to "unresolved"
+        # and was misreported as crash evidence -- IGNORE was only recognized bare.
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE(:.+)?\s*$)/
           group_results[:ignored] += 1
           group_results[:output] << $1
 
@@ -260,13 +264,17 @@ class GeneratorTestResultsBacktrace
       # 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*$)/
+        # Success test case -- tolerates a trailing duration suffix (e.g. `PASS (12 ms)`,
+        # UNITY_INCLUDE_EXEC_TIME), matching the real format generator_test_results.rb's
+        # own parser already recognizes for it.
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:PASS(\s\(.*ms\))?\s*$)/
           group_results[:passed]  += 1
           group_results[:output] << $1
 
-        # Ignored test case
-        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE\s*$)/
+        # Ignored test case -- tolerates a trailing message (TEST_IGNORE_MESSAGE), same as
+        # FAIL below. Before this fix, a message-carrying ignore fell through to "unresolved"
+        # and was misreported as crash evidence -- IGNORE was only recognized bare.
+        when /(^#{Regexp.escape(filename)}:\d+:#{Regexp.escape(test_case[:test])}:IGNORE(:.+)?\s*$)/
           group_results[:ignored] += 1
           group_results[:output] << $1
 

data/lib/ceedling/generators/generator_test_runner.rb

@@ -7,6 +7,7 @@
 
 require 'generate_test_runner' # Unity's test runner generator
 require 'ceedling/parsing_parcels'
+require 'ceedling/includes/includes'
 
 class GeneratorTestRunner
 
@@ -38,7 +39,30 @@ class GeneratorTestRunner
       @test_cases_internal,
       # Small hack for mock subdirectory support until include paths fully supported
       mocks.map{ |include| include.filepath },
-      includes.map{ |include| include.filename }
+      # Unity's own generator emits a string verbatim if it contains '<' and otherwise
+      # wraps it in double quotes -- each entry here must therefore already be in its
+      # final, exact form.
+      #
+      # System includes only: use the full, bracketed spelling (include_path, a
+      # reconciled SystemInclude's original as-written directive text -- e.g.
+      # "sys/stat.h" -- when set, else the directory-preserving filepath). A bare
+      # filename here drops both the directory component and the '<>' delimiters a
+      # system header's own search path depends on (issue #1236).
+      #
+      # User includes: bare filename, same as always. Unlike mocks (whose subdirectory
+      # is a real, dedicated build/test/mocks/<test>/ path -- hence their own
+      # directory-preserving filepath usage above) or a system header (whose directory
+      # is meaningful to the system include search path), a project's own directories
+      # are exposed to the compiler as a flat list of -I search paths, not nested to
+      # match whatever directory component a captured UserInclude's filepath happens to
+      # carry -- rendering the full path here breaks resolution instead of fixing it.
+      includes.map do |include|
+        if include.is_a?(SystemInclude)
+          "<#{include.include_path || include.filepath}>"
+        else
+          include.filename
+        end
+      end
     )
   end
 

data/lib/ceedling/partials/partializer.rb

@@ -125,8 +125,15 @@ class Partializer
 
     partials.each do |_module, config|
       # Remap mockable interface headers that will be injected into generated partial implementation
+      #
+      # Any real (non-nil) mock mode means this module has a generated mock interface header
+      # to redirect to -- PUBLIC/PRIVATE alone once covered every mode that existed, but DEDUCT
+      # (MOCK_PARTIAL_ALL_MODULE) and ACCUMULATE (MOCK_PARTIAL_MODULE) were added later without
+      # updating this check, so a module mocked via either of those was silently never
+      # redirected: its real header (and any static inline/static function bodies in it) stayed
+      # #include'd verbatim, compiling straight past the mock instead of being replaced by it.
       if includes.any? { |include| include.filename.ext().downcase() == _module.downcase() }
-        if [PUBLIC, PRIVATE].include?( config.mocks.type )
+        if !config.mocks.type.nil?
           # Insert mockable interface header from remapping of module name
           _includes << UserInclude.new(
             @file_path_utils.form_partial_interface_header_filename(_module)

data/lib/ceedling/plugins/plugin_reportinator.rb

@@ -95,6 +95,15 @@ class PluginReportinator
     return aggregated_results
   end
       
+  # A build's own test results -- pass or fail -- are core information a user
+  # silencing routine build chatter still wants to see; ERRORS is the floor
+  # for both, not just for a failing run. Centralized here so every plugin
+  # printing post-build test results (report_tests_stdout_plugin, gcov,
+  # valgrind) agrees on the same answer instead of each hardcoding its own.
+  def test_results_floor_verbosity
+    Verbosity::ERRORS
+  end
+
   def run_test_results_report(hash, verbosity=Verbosity::NORMAL)
     if @test_results_template.nil?
       raise CeedlingException.new( "No test results report template has been set." )

data/lib/ceedling/plugins/report_tests_stdout_plugin.rb

@@ -50,7 +50,7 @@ class ReportTestsStdoutPlugin < Plugin
 
     results = @plugin_reportinator.assemble_test_results( @result_list )
     hash = { :context => TEST_SYM, :results => results }
-    verbosity = (results[:counts][:failed] > 0) ? Verbosity::ERRORS : Verbosity::NORMAL
+    verbosity = @plugin_reportinator.test_results_floor_verbosity
 
     # Print unit test suite results
     @plugin_reportinator.run_test_results_report( hash, verbosity )

data/lib/ceedling/preprocess/preprocessinator.rb

@@ -567,6 +567,28 @@ class Preprocessinator
         defines:       defines
       )
 
+      # Supplement with a literal text scan of the original file's own #include
+      # lines -- the gcc-based bare pass above runs against an isolated copy that
+      # can never open another header, so a conditional #include whose guard
+      # depends on a macro defined by an *earlier #include in this same file*
+      # evaluates false there and silently drops out. Unioning in this text-based
+      # pass's result only ever adds candidates for Includes.reconcile below to
+      # match against the accurate directives-only pass -- it can't introduce a
+      # spurious entry on its own, since reconcile still requires the accurate
+      # pass to also report it.
+      #
+      # This supplements the gcc-based pass rather than replacing it: gcc can
+      # resolve an #include whose target is itself a macro (e.g. the
+      # MOCK_PARTIAL_ALL_MODULE()-style directives this project's own generated
+      # test files use), since a command-line -D define is visible even to the
+      # isolated copy -- a literal text scan has no filename there to find at
+      # all, since none exists until a real preprocessor expands the macro. The
+      # two passes catch different, non-overlapping failure modes; keeping both
+      # covers both.
+      bare_includes = (
+        bare_includes + @includes_handler.extract_bare_includes_from_text( filepath: filepath )
+      ).uniq( &:filename )
+
       # Extract user includes
       user_includes = preprocess_user_includes(
         name:                     test,

data/lib/ceedling/preprocess/preprocessinator_includes_handler.rb

@@ -115,6 +115,39 @@ class PreprocessinatorIncludesHandler
     return includes
   end
 
+  # Scan the original file's own text for every #include line, unconditionally --
+  # no #if/#ifdef tracking at all, just literal presence. Supplements the gcc-based
+  # bare pass (`extract_bare_includes`), which runs against an isolated, sibling-free
+  # copy of the file and so can never open another header to resolve a conditional
+  # that depends on a macro that header defines (e.g. `#if SOME_MACRO_FROM_ANOTHER_HEADER`)
+  # -- GCC treats the macro as undefined there and silently drops the #include line
+  # from that pass's output even though it's a perfectly ordinary, real, top-level
+  # #include once actually evaluated with the real file in place. This method's result
+  # is meant to be unioned with the gcc-based bare pass's own result (see
+  # Preprocessinator#preprocess_file_includes_common), not used on its own -- an
+  # `Includes.reconcile` call downstream still only keeps an entry here if the
+  # accurate directives-only pass also reports it, so unconditionally capturing every
+  # literal #include line (regardless of whether its own guard is really true) is
+  # safe: it can only ever let back in an entry the accurate pass already confirmed,
+  # never introduce a spurious one on its own. A supplement, not a replacement --
+  # the gcc pass can still do something this literal scan structurally can't: resolve
+  # an #include whose own target is a macro rather than a literal filename.
+  def extract_bare_includes_from_text(filepath:)
+    includes = []
+
+    # Open in binary mode: code_lines applies clean_encoding per-line, but each_line
+    # itself can raise on invalid byte sequences before clean_encoding is reached.
+    @file_wrapper.open(filepath, 'rb') do |input|
+      @parsing_parcels.code_lines( input ) do |line|
+        _include = @include_factory.user_include_from_directive( line ) ||
+                   @include_factory.system_include_from_directive( line )
+        includes << Include.new( _include.filepath ) if !_include.nil?
+      end
+    end
+
+    return clean_self_reference( filepath, includes )
+  end
+
   def extract_user_includes_preprocess(name:, filepath:, preprocessed_filepath:)
     includes = []
 

data/lib/version.rb

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

data/plugins/gcov/config/defaults.yml

@@ -27,7 +27,6 @@
 
   :report_generator:
     :verbosity: Warning           # Default verbosity
-    :collection_paths_source: []  # Explicitly defined as default empty array to simplify option validation code
     :custom_args: []              # Explicitly defined as default empty array to simplify option validation code
     :gcov_exclude: []             # Explicitly defined as default empty array to simplify option validation code
 ...

data/plugins/gcov/lib/gcov.rb

@@ -40,11 +40,19 @@ class Gcov < Plugin
       )
     end
 
-    # Validate configuration and tools while building Reportinators
-    @reportinators = build_reportinators( 
-      @project_config[:gcov_utilities],
-      @reports_enabled
-    )
+    # #1252 -- Validate `:gcov ↳ :utilities` config (cheap, no external tool needed) and
+    # build the console summary Reportinator (needs no external tool of its own) here,
+    # eagerly, since `setup()` runs for every build this plugin is merely *enabled* for,
+    # not only real `gcov:` builds. Deliberately NOT building the gcovr/ReportGenerator
+    # Reportinators here -- doing so validates gcovr/ReportGenerator are installed
+    # (see their own constructors), which would make either a hard dependency of any
+    # build at all (e.g. plain `test:all`) rather than only a real `gcov:` build. See
+    # generate_coverage_reports, which builds (and so validates) them lazily, only once
+    # post_build already knows a gcov: task actually ran.
+    validate_utilities_config( @project_config[:gcov_utilities] )
+    @console_reportinator = summaries_enabled?( @project_config ) ?
+      ConsoleReportinator.new( @ceedling, @project_config ) : nil
+    @reportinators = nil
 
     # Convenient instance variable references
     @configurator = @ceedling[:configurator]
@@ -214,7 +222,7 @@ class Gcov < Plugin
         results: results
       }
 
-      verbosity = (results[:counts][:failed] > 0) ? Verbosity::ERRORS : Verbosity::NORMAL
+      verbosity = @plugin_reportinator.test_results_floor_verbosity
 
       # Print unit test suite results
       @plugin_reportinator.run_test_results_report( hash, verbosity )
@@ -257,6 +265,15 @@ class Gcov < Plugin
   def generate_coverage_reports()
     return if not @reports_enabled
 
+    # #1252 -- Lazily build (and so validate the external tools of) the gcovr/
+    # ReportGenerator Reportinators only now: this method only runs from post_build
+    # (automatic reporting) or the standalone `gcov:report` task (manual reporting,
+    # mutually exclusive with automatic per :gcov_report_task) -- either way, only
+    # once a real gcov: task is confirmed to have already run. See setup()'s own
+    # comment for why this can't happen any earlier. `||=` just guards against ever
+    # rebuilding (and so re-validating) on a hypothetical repeat call.
+    @reportinators ||= build_reportinators( @project_config[:gcov_utilities] )
+
     @reportinators.each do |reportinator|
       # Create the artifacts output directory.
       @file_wrapper.mkdir( reportinator.artifacts_path ) if reportinator.artifacts_path
@@ -312,16 +329,10 @@ class Gcov < Plugin
     return sources - tested_sources
   end
 
-  def build_reportinators(config, enabled)
-    reportinators = []
-
-    # Instantiate console summary reportinator if summaries enabled
-    @console_reportinator = summaries_enabled?(@project_config) ?
-      ConsoleReportinator.new(@ceedling, @project_config) : nil
-
-    # Do not instantiate file reportinators (and tool validation) unless reports enabled
-    return reportinators if (!enabled)
-
+  # Fail fast at plugin setup if :utilities holds an unrecognized name (e.g. a typo) --
+  # cheap, config-shape-only validation, so this stays eager even though the actual
+  # Reportinators it names are built lazily (see build_reportinators, generate_coverage_reports).
+  def validate_utilities_config(config)
     config.each do |reportinator|
       if not GCOV_UTILITY_NAMES.map(&:upcase).include?( reportinator.upcase )
         options = GCOV_UTILITY_NAMES.map{ |utility| "'#{utility}'" }.join(', ')
@@ -329,6 +340,14 @@ class Gcov < Plugin
         raise CeedlingException.new(msg)
       end
     end
+  end
+
+  # #1252 -- Deliberately not called from setup(); see its own comment and
+  # generate_coverage_reports, the only caller. Constructing GcovrReportinator/
+  # ReportGeneratorReportinator validates gcovr/ReportGenerator are installed, so this
+  # can only run once a real gcov: task is confirmed to have run.
+  def build_reportinators(config)
+    reportinators = []
 
     # Run reports using gcovr
     if utility_enabled?( config, GCOV_UTILITY_NAME_GCOVR )