ceedling 1.1.9 → 1.2.0

data/plugins/gcov/lib/console_reportinator.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
+require 'ceedling/path_mirror'
 require 'gcov_reportinator'
 
 class ConsoleReportinator < GcovReportinator
@@ -19,10 +20,12 @@ class ConsoleReportinator < GcovReportinator
   def initialize(system_objects, config)
     super(config)
 
-    @loginator           = system_objects[:loginator]
-    @plugin_reportinator = system_objects[:plugin_reportinator]
-    @test_invoker        = system_objects[:test_invoker]
-    @tool_executor       = system_objects[:tool_executor]
+    @configurator         = system_objects[:configurator]
+    @loginator            = system_objects[:loginator]
+    @plugin_reportinator  = system_objects[:plugin_reportinator]
+    @test_invoker         = system_objects[:test_invoker]
+    @tool_executor        = system_objects[:tool_executor]
+    @file_path_utils      = system_objects[:file_path_utils]
   end
 
   def generate_reports(opts, untested_sources: [])
@@ -33,12 +36,27 @@ class ConsoleReportinator < GcovReportinator
     @test_invoker.each_test_with_sources do |test, sources|
       @loginator.log( @plugin_reportinator.generate_heading( test ) )
 
-      _sources = remap_partial_sources( sources )
-      _sources.each do |source|
+      # Collected before any report is logged, because a label can only be made
+      # unambiguous once every file this test reports on is known. The path a file is
+      # reported under is gcov's own where it could be parsed -- for a Partial that is the
+      # original module, which #line directives remap it to -- and the queried source
+      # otherwise.
+      reports = remap_partial_sources( sources ).filter_map do |source|
         results = run_gcov_summary( test, source, opts )
         next if results.nil?
+
         gcov_source = extract_gcov_source_path( results, test, source )
-        log_coverage_report( test, source, results, gcov_source )
+
+        { source: source, results: results, gcov_source: gcov_source }
+      end
+
+      labels = disambiguated_labels( reports.map { |report| reported_path( report ) } )
+
+      reports.each do |report|
+        log_coverage_report(
+          test, report[:source], report[:results], report[:gcov_source],
+          label: labels[ reported_path( report ) ]
+        )
       end
     end
 
@@ -49,6 +67,45 @@ class ConsoleReportinator < GcovReportinator
 
   private
 
+  # The path a file's coverage is reported under.
+  def reported_path(report)
+    return report[:gcov_source].empty? ? report[:source] : report[:gcov_source]
+  end
+
+  # A display label per path, each the shortest trailing path that distinguishes it from
+  # every other path sharing its basename.
+  #
+  # A basename alone is ambiguous the moment one test reports on two modules of the same
+  # name, which says nothing about which module a coverage line belongs to. Case is
+  # preserved, unlike path matching elsewhere: these are read by a person.
+  def disambiguated_labels(paths)
+    paths.uniq.group_by { |path| File.basename( path ) }.each_with_object({}) do |(_basename, group), labels|
+      depth = label_depth( group )
+
+      group.each { |path| labels[path] = display_segments( path ).last( depth ).join( '/' ) }
+    end
+  end
+
+  # The fewest trailing segments that tell every path in `group` apart. Falls back to the
+  # longest path's own depth when even whole paths repeat, which cannot be improved on.
+  def label_depth(group)
+    return 1 if group.length < 2
+
+    deepest = group.map { |path| display_segments( path ).length }.max
+
+    (1..deepest).each do |depth|
+      tails = group.map { |path| display_segments( path ).last( depth ) }
+
+      return depth if tails.uniq.length == group.length
+    end
+
+    return deepest
+  end
+
+  def display_segments(path)
+    return path.split( %r{[\\/]} ).reject(&:empty?)
+  end
+
   def log_untested_sources_section(untested_sources)
     @loginator.log( @plugin_reportinator.generate_heading("Untested Source Files") )
 
@@ -57,23 +114,82 @@ class ConsoleReportinator < GcovReportinator
     end
   end
 
+  # Remap sources: if Partial files are present, remove the original source file they replace.
+  # Coverage is then reported against the Partial implementation rather than the original module.
+  #
+  # A Partial replaces one module, identified by its path. Generated Partials and real
+  # sources sit below different roots, so neither path is a suffix of the other and the
+  # two can only be related by the namespace they share. Each Partial therefore claims
+  # the source it shares the longest trailing path with. Matching on basename alone would
+  # drop every same-named module, and one nobody Partialized would lose its coverage
+  # report entirely.
   def remap_partial_sources(sources)
-    # Remap sources: if Partial files are present, remove the original source file they replace.
-    # Coverage is then reported against the Partial implementation rather than the original module.
     partials = sources.select { |s| File.basename(s).match?(PATTERNS::PARTIAL_IMPL_FILENAME) }
     return sources if partials.empty?
 
-    # Extract module names covered by Partials (strip prefix and _impl suffix)
-    partialized = partials.map { |p|
-      File.basename(p, '.*').delete_prefix(PARTIAL_FILENAME_PREFIX).delete_suffix('_impl')
-    }
-    # Drop any original source file whose module is now covered by a Partial
-    sources.reject { |s| partialized.include?( File.basename(s, '.*') ) }
+    originals = sources.reject { |s| File.basename(s).match?(PATTERNS::PARTIAL_IMPL_FILENAME) }
+    replaced  = []
+
+    partials.each do |partial|
+      query = partial_module_segments( partial )
+
+      scored = originals.map { |source| [source, common_suffix_length( query, source_segments( source ) )] }
+                        .reject { |_source, length| length.zero? }
+
+      next if scored.empty?
+
+      best = scored.map { |_source, length| length }.max
+
+      replaced += scored.select { |_source, length| length == best }.map(&:first)
+    end
+
+    return sources - replaced
+  end
+
+  # The module a generated Partial replaces, as path segments. The reversal itself belongs
+  # to the same place that builds these filenames, so prefix and suffix knowledge stays in
+  # one place; the mirrored subdirectory survives as the module's own path.
+  def partial_module_segments(filepath)
+    _module = @file_path_utils.module_from_partial_filename( filepath )
+
+    return [] if _module.nil?
+
+    return PathMirror.path_segments( _module )
+  end
+
+  def source_segments(filepath)
+    return PathMirror.path_segments( filepath.sub( /\.[^.\/\\]*\z/, '' ) )
+  end
+
+  # How many trailing segments two paths have in common. Zero means even the basenames
+  # differ, so the two cannot name the same module.
+  def common_suffix_length(left, right)
+    length = 0
+    length += 1 while length < left.length && length < right.length &&
+                      left[-(length + 1)] == right[-(length + 1)]
+    return length
   end
 
   def run_gcov_summary(test, source, opts)
     filename = File.basename(source)
 
+    # A module-under-test's object (and its accompanying .gcno/.gcda) mirrors its source's own
+    # subdirectory below whichever configured root it came from -- the same convention its actual
+    # compile step already follows -- so the directory gcov is told to search must include that
+    # mirrored subdirectory too, not just the flat <build>/gcov/out/<test name> root.
+    # A generated Partial sits below its own test's Partials build root rather than a
+    # configured source root, so the source roots mirror nothing for it. Its own root is
+    # what carries the module's subdirectory.
+    roots =
+      if File.basename(source).match?(PATTERNS::PARTIAL_IMPL_FILENAME)
+        [File.join( @configurator.project_test_partials_path, test )]
+      else
+        @configurator.paths_source + @configurator.paths_support
+      end
+
+    subdir  = PathMirror.relative_subdir( source, roots )
+    obj_dir = subdir.empty? ? File.join(GCOV_BUILD_OUTPUT_PATH, test) : File.join(GCOV_BUILD_OUTPUT_PATH, test, subdir)
+
     # Run gcov to extract the coverage summary
     command = @tool_executor.build_command_line(
       TOOLS_GCOV_SUMMARY,
@@ -81,7 +197,7 @@ class ConsoleReportinator < GcovReportinator
       (opts[:gcov_mcdc] ? ['-g'] : []),
       # Argument replacement
       filename, # .c source file compiled with coverage
-      File.join(GCOV_BUILD_OUTPUT_PATH, test) # <build>/gcov/out/<test name> for coverage data files
+      obj_dir # <build>/gcov/out/<test name>[/mirrored subdir] for coverage data files
     )
 
     # Do not raise an exception if `gcov` terminates with a non-zero exit code, just note it and move on.
@@ -93,9 +209,9 @@ class ConsoleReportinator < GcovReportinator
     results       = shell_results[:output].strip
 
     # Handle errors instead of raising a shell exception
-    if shell_results[:exit_code] != 0
+    if @tool_executor.failed?( shell_results )
       @loginator.lazy( Verbosity::DEBUG, LogLabels::ERROR ) do
-        "gcov error (#{shell_results[:exit_code]}) while processing #{filename}... #{results}"
+        "gcov error (#{shell_results[:status]&.exitstatus}) while processing #{filename}... #{results}"
       end
       @loginator.lazy( Verbosity::COMPLAIN ) do
         "gcov was unable to process coverage for #{filename}"
@@ -145,7 +261,7 @@ class ConsoleReportinator < GcovReportinator
   # gcov_source  — absolute path extracted from the `File '...'` line in gcov output; for Partial files
   #                this is the original module source (due to #line remapping), not the Partial filepath;
   #                empty string ('') when the gcov File header could not be parsed
-  def log_coverage_report(test, source, results, gcov_source)
+  def log_coverage_report(test, source, results, gcov_source, label: nil)
     filename = File.basename(source)
 
     # If gcov results include intended source (comparing absolute paths), report coverage details summaries.
@@ -155,6 +271,10 @@ class ConsoleReportinator < GcovReportinator
       # For Partials, use the original source name from gcov output (gcov_source) rather than the Partial filename.
       report_name = gcov_source.empty? ? filename : File.basename(gcov_source)
 
+      # The basename still matches gcov's own File header; only the printed label carries
+      # the disambiguating path.
+      report_label = label || report_name
+
       lines = results.lines
       # Find the File header line matching the queried source filename
       start_idx = lines.index { |l| l.start_with?('File') && l.include?(report_name) }
@@ -167,7 +287,7 @@ class ConsoleReportinator < GcovReportinator
         section       = next_file_idx ? remaining[0...next_file_idx] : remaining
         # Filter out gcov informational messages emitted while inspecting coverage binary files
         section       = section.reject { |line| line.include?( File.basename( source,'.*') ) }
-        report        = section.map { |line| report_name + ' | ' + line }.join('')
+        report        = section.map { |line| report_label + ' | ' + line }.join('')
         @loginator.log( report )
       else
         # A Partial whose remapped name still doesn't match any File header in gcov's

data/plugins/gcov/lib/gcov.rb

@@ -16,7 +16,21 @@ require 'gcovr_reportinator'
 require 'reportgenerator_reportinator'
 
 class Gcov < Plugin
-  
+
+  include ToolVersionGating
+
+  # Checked lazily (see validate_mcdc_gcc_version!, called from the gcov-context build
+  # hooks below) rather than here in setup(), which 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_VERSION_GATE = {
+    :mcdc => {
+      min: [14, 0],
+      message: ":gcov ↳ :mcdc ➡️ Modified condition/decision coverage requires GCC %{req} or higher (found %{found})"
+    }
+  }.freeze
+
   # `Plugin` setup()
   def setup
     @result_list = []
@@ -59,22 +73,28 @@ class Gcov < Plugin
     @loginator = @ceedling[:loginator]
     @reportinator = @ceedling[:reportinator]
     @test_invoker = @ceedling[:test_invoker]
-    @flaginator = @ceedling[:flaginator]
-    @defineinator = @ceedling[:defineinator]
+    @test_build_setup = @ceedling[:test_build_setup]
     @generator = @ceedling[:generator]
     @plugin_reportinator = @ceedling[:plugin_reportinator]
     @file_path_utils = @ceedling[:file_path_utils]
     @file_wrapper = @ceedling[:file_wrapper]
     @tool_executor = @ceedling[:tool_executor]
     @plugin_manager = @ceedling[:plugin_manager]
+    @dependinator = @ceedling[:dependinator]
+
+    # Cloned from the original, unflattened project config (project_config_hash
+    # above has none of this -- flattening leaves no nested :gcov key) so the whole
+    # section can ride along as dependency-tracker meta alongside the specific
+    # :tools/:flags tracking elsewhere in this file, the same belt-and-suspenders
+    # reasoning :cmock's own whole-section meta capture already uses -- a future
+    # :gcov config key that affects a tracked target's real behavior is covered
+    # automatically, without needing its own dedicated wiring here first.
+    @gcov_config = @ceedling[:setupinator].config_hash[:gcov].clone
 
     @mutex = Mutex.new()
 
-    # 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`.
+    # See validate_mcdc_gcc_version! and MCDC_GCC_VERSION_GATE above for why this isn't
+    # checked eagerly here.
     @mcdc_gcc_checked = false
   end
 
@@ -124,6 +144,8 @@ class Gcov < Plugin
       @loginator.log_list( untested_sources.sort, header, Verbosity::COMPLAIN, LogLabels::WARNING )
 
     when GCOV_UNTESTED_SOURCES_COMPILE
+      validate_mcdc_gcc_version!
+
       msg = 'Processing Untested Sources'
       msg = @reportinator.generate_heading( @loginator.decorate( msg, LogLabels::RUN ) )
       @loginator.log( msg )
@@ -136,22 +158,62 @@ class Gcov < Plugin
         return
       end
 
+      skipped = 0
+
       untested_sources.each do |filepath|
-        filename = File.basename(filepath)
+        filename     = File.basename(filepath)
+        object       = @file_path_utils.form_test_object_filepath( filepath, context:GCOV_SYM )
+        dependencies = @file_path_utils.form_test_dependencies_filepath( filepath, context:GCOV_SYM )
+        search_paths = @configurator.collection_paths_include
+        # Defines and flags resolve as a tested source's do, against this source's filepath
+        defines      = @test_build_setup.context_defines( context:GCOV_SYM, filepath:filepath )
+
+        # Same MC/DC condition pre_test_compile_register applies for ordinary test-context
+        # compiles -- this path calls Generator directly, bypassing TestBuildExecutor
+        # (and therefore that hook) entirely, so it has to apply the flag itself.
+        flags = @test_build_setup.flags( context:GCOV_SYM, operation:OPERATION_COMPILE_SYM, filepath:filepath )
+        flags += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
+
+        # Same register/stale?/mark_fresh idiom TestBuildExecutor's own object
+        # compilation uses -- this compile happens entirely outside that pipeline
+        # (untested sources have no test of their own to drive them through it), so
+        # nothing else registers it. :gcov meta is the whole section, same
+        # belt-and-suspenders reasoning as pre_test_compile_register above.
+        @dependinator.register(
+          object, files: [filepath],
+          meta: { flags: flags, defines: defines, search_paths: search_paths, tools: [TOOLS_GCOV_COMPILER], gcov: @gcov_config }
+        )
+        @dependinator.register_gcc_deps_file( dependencies ) if @file_wrapper.exist?( dependencies )
+
+        unless @dependinator.stale?( object )
+          msg = @reportinator.generate_module_progress(
+            operation:   'Skipping untested-source compilation for',
+            module_name: filename.ext(),
+            filename:    filename
+          )
+          @loginator.log( msg, Verbosity::OBNOXIOUS )
+          skipped += 1
+          next
+        end
+
         begin
           @generator.generate_object_file_c(
             tool:         TOOLS_GCOV_COMPILER,
             module_name:  filename.ext(),
             context:      GCOV_SYM,
             source:       filepath,
-            object:       @file_path_utils.form_test_object_filepath( filepath, context:GCOV_SYM ),
-            search_paths: @configurator.collection_paths_include,
-            flags:        @flaginator.flag_down( context:GCOV_SYM, operation:OPERATION_COMPILE_SYM ),
-            defines:      @defineinator.defines( subkey:GCOV_SYM ),
-            dependencies: @file_path_utils.form_test_dependencies_filepath( filepath, context:GCOV_SYM )
+            object:       object,
+            search_paths: search_paths,
+            flags:        flags,
+            defines:      defines,
+            dependencies: dependencies
           )
+
+          @dependinator.register_gcc_deps_file( dependencies ) if @file_wrapper.exist?( dependencies )
+          @dependinator.mark_fresh( object )
         rescue ShellException => ex
-          # Log actionable guidance then re-raise immediately (omitted when `guidance` is false)
+          # Log actionable guidance then re-raise immediately (omitted when `guidance` is false) --
+          # left un-marked-fresh, so the next run retries this same source.
           if guidance
             notice = "Compiling untested '#{filename}' with coverage failed.\n" \
                      "NOTE: Compilation of an untested source for coverage (:gcov ↳ :untested_sources ➡️ :compile) " \
@@ -166,36 +228,72 @@ class Gcov < Plugin
           raise ex
         end
       end
+
+      # TestInvoker's own flush (test_invoker.rb) already ran and persisted by the
+      # time this method runs (see gcov.rake -- this is always called after
+      # setup_and_invoke returns) -- this flush persists the additional entries
+      # registered above on top of that, safely: flush doesn't clear in-memory
+      # state, so this just writes out the superset to the same already-open cache.
+      @dependinator.flush( refresh_dependencies: false )
+
+      msg = @reportinator.generate_skip_summary( task: "compilation", count: skipped, noun: "untested sources" )
+      @loginator.log( msg ) unless msg.nil?
     end
   end
 
+  # Swaps in the coverage-instrumented compiler (and MC/DC flag, if configured) ahead
+  # of TestBuildExecutor's own dependency-tracker meta capture, so a change to either
+  # is what actually invalidates a gcov-context object's cache -- not the plain test
+  # compiler this replaces. Compile all non-assembly files with coverage; gcovr
+  # --exclude filters non-production files from reports.
+  def pre_test_compile_register(arg_hash)
+    return unless arg_hash[:context] == GCOV_SYM
+    return if EXTENSION_ASSEMBLY.match?(arg_hash[:source])
+
+    validate_mcdc_gcc_version!
+
+    arg_hash[:tool] = TOOLS_GCOV_COMPILER
+    arg_hash[:flags] += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
+
+    # The whole :gcov config as meta, redundant alongside the :mcdc-derived flag
+    # above -- belt-and-suspenders against a future :gcov key affecting a compile
+    # this file doesn't yet know to thread through by hand, the same reasoning
+    # :cmock's own whole-section meta capture already uses. Additive: merges with
+    # TestBuildExecutor's own register call for this same target moments later.
+    @dependinator.register( arg_hash[:object], meta: { gcov: @gcov_config } )
+  end
+
   def pre_compile_execute(arg_hash)
-    if arg_hash[:context] == GCOV_SYM
-      source = arg_hash[:source]
-
-      # 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",
-          module_name: arg_hash[:module_name],
-          filename: File.basename(source)
-        )
-        arg_hash[:flags] += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
-      end
-    end
+    return unless arg_hash[:context] == GCOV_SYM
+    return if EXTENSION_ASSEMBLY.match?(arg_hash[:source])
+
+    arg_hash[:msg] = @reportinator.generate_module_progress(
+      operation: "Compiling with coverage",
+      module_name: arg_hash[:module_name],
+      filename: File.basename(arg_hash[:source])
+    )
   end
 
-  def pre_link_execute(arg_hash)
-    if arg_hash[:context] == GCOV_SYM
-      validate_mcdc_gcc_version!
+  # As pre_test_compile_register above, for the coverage-instrumented linker. Fires every
+  # run regardless of whether this executable actually needs relinking, which is also
+  # what lets post_build's summary print correctly even on a fully-cached gcov:all
+  # re-run -- @cli_gcov_task marks that a gcov: task ran at all, not that a link did.
+  def pre_test_link_register(arg_hash)
+    return unless arg_hash[:context] == GCOV_SYM
 
-      @cli_gcov_task = true
-      arg_hash[:tool] = TOOLS_GCOV_LINKER
-      arg_hash[:flags] += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
-    end
+    validate_mcdc_gcc_version!
+
+    @cli_gcov_task = true
+    arg_hash[:tool] = TOOLS_GCOV_LINKER
+    arg_hash[:flags] += ['-fcondition-coverage'] if @project_config[:gcov_mcdc]
+
+    # See pre_test_compile_register above -- same belt-and-suspenders reasoning, same
+    # additive merge with TestBuildExecutor's own register call for this target.
+    @dependinator.register( arg_hash[:executable], meta: { gcov: @gcov_config } )
+  end
+
+  def pre_test_fixture_register(arg_hash)
+    arg_hash[:tool] = TOOLS_GCOV_FIXTURE if arg_hash[:context] == GCOV_SYM
   end
 
   # `Plugin` build step hook
@@ -203,7 +301,11 @@ class Gcov < Plugin
     result_file = arg_hash[:result_file]
 
     @mutex.synchronize do
-      if (result_file =~ /#{GCOV_RESULTS_PATH}/) && !@result_list.include?(result_file)
+      # #104 -- `[`/`]` are legal filename characters, but also regex character-class
+      # syntax; interpolating GCOV_RESULTS_PATH into this regex unescaped means a
+      # literal bracket anywhere in it (e.g. a bracket-containing :build_root:) silently
+      # breaks this match, and the test never gets counted here.
+      if (result_file =~ /#{Regexp.escape(GCOV_RESULTS_PATH)}/) && !@result_list.include?(result_file)
         @result_list << arg_hash[:result_file]
       end
     end
@@ -366,40 +468,33 @@ class Gcov < Plugin
 
   # 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.
+  # untested-source compile, link), memoized so `gcc --version` runs at most once
+  # regardless of how many source files or hooks fire before it. See MCDC_GCC_VERSION_GATE
+  # above for why this isn't checked eagerly in setup().
   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
+    enforce_version_gates!(
+      { mcdc: @project_config[:gcov_mcdc] },
+      get_gcc_version(),
+      MCDC_GCC_VERSION_GATE
+    )
   end
 
+  # Get the GCC version number as a ToolVersion struct.
   def get_gcc_version()
-    command = @tool_executor.build_command_line( TOOLS_GCOV_GCC_VERSION, [])
-
     @loginator.lazy( Verbosity::OBNOXIOUS ) do
       @reportinator.generate_progress("Collecting GCC version for conditional feature handling")
     end
 
-    shell_result = @tool_executor.exec( command )
-
     # First line of gcc --version: "gcc[.exe] (...platform info...) major.minor.patch"
-    version_match = shell_result[:output].match(/^gcc(?:#{Regexp.escape(EXTENSION_WIN_EXE)})?\s+.*\s+(\d+)\.(\d+)\.\d+/)
-
-    if version_match.nil? || version_match[1].nil? || version_match[2].nil?
-      raise CeedlingException.new("Could not collect `gcc` version from its command line")
-    end
-
-    return GcovToolVersion.new( version_match[1].to_i, version_match[2].to_i )
+    detect_tool_version(
+      TOOLS_GCOV_GCC_VERSION,
+      /^gcc(?:#{Regexp.escape(EXTENSION_WIN_EXE)})?\s+.*\s+(\d+)\.(\d+)\.\d+/,
+      tool_label: 'gcc'
+    )
   end
 
 end

data/plugins/gcov/lib/gcov_constants.rb

@@ -28,13 +28,9 @@ GCOV_GCOVR_ARTIFACTS_FILE_HTML        = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "Gc
 GCOV_GCOVR_ARTIFACTS_FILE_COBERTURA   = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverageCobertura.xml")
 GCOV_GCOVR_ARTIFACTS_FILE_SONARQUBE   = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverageSonarQube.xml")
 GCOV_GCOVR_ARTIFACTS_FILE_JSON        = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverage.json")
-
-TOOL_COLLECTION_GCOV_TASKS = {
-  :test_compiler  => TOOLS_GCOV_COMPILER,
-  :test_assembler => TOOLS_TEST_ASSEMBLER,
-  :test_linker    => TOOLS_GCOV_LINKER,
-  :test_fixture   => TOOLS_GCOV_FIXTURE
-}
+GCOV_GCOVR_ARTIFACTS_FILE_JACOCO      = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverageJaCoCo.xml")
+GCOV_GCOVR_ARTIFACTS_FILE_LCOV        = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverage.lcov")
+GCOV_GCOVR_DEFAULT_TEXT_ARTIFACT_FILENAME = "coverage.txt".freeze
 
 # Report Creation Utilities
 GCOV_UTILITY_NAME_GCOVR = "gcovr"
@@ -63,6 +59,7 @@ class ReportTypes
   COBERTURA = "Cobertura"
   SONARQUBE = "SonarQube"
   JSON = "JSON"
+  JACOCO = "JaCoCo"
   BADGES = "Badges"
   CSV_SUMMARY = "CsvSummary"
   LATEX = "Latex"