ceedling 0.9.0 → 1.0.1

data/plugins/gcov/config/defaults.yml

@@ -0,0 +1,30 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+---
+:gcov:
+  :summaries: TRUE                # Enable simple coverage summaries to console after tests
+  :report_task: FALSE             # Disabled dedicated report generation task (this enables automatic report generation)
+
+  :utilities:
+    - gcovr                       # Defaults to `gcovr` as report generation utility
+
+  :reports: []                    # User must specify a report to enable report generation
+
+  :gcovr:
+    :report_root: "."             # Gcovr defaults to scanning for results starting in working directory
+
+                                  # For v6.0+ merge coverage results for same function tested multiple times
+                                  # The default behavior is 'strict' which will cause a gcovr exception for many users
+    :merge_mode_function: merge-use-line-max
+
+  :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/config/defaults_gcov.rb

@@ -0,0 +1,109 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+DEFAULT_GCOV_COMPILER_TOOL = {
+  :executable => FilePathUtils.os_executable_ext('gcc').freeze,
+  :name => 'default_gcov_compiler'.freeze,
+  :optional => false.freeze,
+  :arguments => [
+    "-g".freeze,
+    "-fprofile-arcs".freeze,
+    "-ftest-coverage".freeze,
+    "-I\"${5}\"".freeze, # Per-test executable search paths
+    "-D\"${6}\"".freeze, # Per-test executable defines
+    "-DGCOV_COMPILER".freeze,
+    "-DCODE_COVERAGE".freeze,
+    "-c \"${1}\"".freeze,
+    "-o \"${2}\"".freeze,
+    # gcc's list file output options are complex; no use of ${3} parameter in default config
+    "-MMD".freeze,
+    "-MF \"${4}\"".freeze,
+    ].freeze
+  }
+
+DEFAULT_GCOV_LINKER_TOOL = {
+  :executable => FilePathUtils.os_executable_ext('gcc').freeze,
+  :name => 'default_gcov_linker'.freeze,
+  :optional => false.freeze,
+  :arguments => [
+    "-g".freeze,
+    "-fprofile-arcs".freeze,
+    "-ftest-coverage".freeze,
+    "${1}".freeze,
+    "${5}".freeze,
+    "-o \"${2}\"".freeze,
+    "${4}".freeze,
+    ].freeze
+  }
+
+DEFAULT_GCOV_FIXTURE_TOOL = {
+  :executable => '${1}'.freeze,
+  :name => 'default_gcov_fixture'.freeze,
+  :optional => false.freeze,
+  :arguments => [].freeze
+  }
+
+# Produce summaries printed to console
+DEFAULT_GCOV_SUMMARY_TOOL = {
+  :executable => FilePathUtils.os_executable_ext('gcov').freeze,
+  :name => 'default_gcov_summary'.freeze,
+  :optional => true.freeze,
+  :arguments => [
+    "-n".freeze,
+    "-p".freeze,
+    "-b".freeze,
+    "-o \"${2}\"".freeze,
+    "\"${1}\"".freeze
+    ].freeze
+  }
+
+# Produce .gcov files (used in conjunction with ReportGenerator)
+DEFAULT_GCOV_REPORT_TOOL = {
+  :executable => FilePathUtils.os_executable_ext('gcov').freeze,
+  :name => 'default_gcov_report'.freeze,
+  :optional => true.freeze,
+  :arguments => [
+    "-b".freeze,
+    "-c".freeze,
+    "-r".freeze,
+    "-x".freeze,
+    "${1}".freeze
+    ].freeze
+  }
+
+# Produce reports with `gcovr`
+DEFAULT_GCOV_GCOVR_REPORT_TOOL = {
+  # No extension handling -- `gcovr` is generally an extensionless Python script
+  :executable => 'gcovr'.freeze,
+  :name => 'default_gcov_gcovr_report'.freeze,
+  :optional => true.freeze,
+  :arguments => [
+    "${1}".freeze
+    ].freeze
+  }
+
+# Produce reports with `reportgenerator`
+DEFAULT_GCOV_REPORTGENERATOR_REPORT_TOOL = {
+  :executable => FilePathUtils.os_executable_ext('reportgenerator').freeze,
+  :name => 'default_gcov_reportgenerator_report'.freeze,
+  :optional => true.freeze,
+  :arguments => [
+    "${1}".freeze
+    ].freeze
+  }
+
+def get_default_config
+  return :tools => {
+    :gcov_compiler => DEFAULT_GCOV_COMPILER_TOOL,
+    :gcov_linker   => DEFAULT_GCOV_LINKER_TOOL,
+    :gcov_fixture  => DEFAULT_GCOV_FIXTURE_TOOL,
+    :gcov_summary  => DEFAULT_GCOV_SUMMARY_TOOL,
+    :gcov_report => DEFAULT_GCOV_REPORT_TOOL,
+    :gcov_gcovr_report => DEFAULT_GCOV_GCOVR_REPORT_TOOL,
+    :gcov_reportgenerator_report => DEFAULT_GCOV_REPORTGENERATOR_REPORT_TOOL
+  }
+end

data/plugins/gcov/gcov.rake

@@ -0,0 +1,100 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'reportgenerator_reportinator'
+require 'gcovr_reportinator'
+
+directory(GCOV_BUILD_OUTPUT_PATH)
+directory(GCOV_RESULTS_PATH)
+directory(GCOV_ARTIFACTS_PATH)
+directory(GCOV_DEPENDENCIES_PATH)
+
+CLEAN.include(File.join(GCOV_BUILD_OUTPUT_PATH, '*'))
+CLEAN.include(File.join(GCOV_RESULTS_PATH, '*'))
+CLEAN.include(File.join(GCOV_ARTIFACTS_PATH, '**/*'))
+CLEAN.include(File.join(GCOV_DEPENDENCIES_PATH, '*'))
+
+CLOBBER.include(File.join(GCOV_BUILD_PATH, '**/*'))
+
+task directories: [GCOV_BUILD_OUTPUT_PATH, GCOV_RESULTS_PATH, GCOV_DEPENDENCIES_PATH, GCOV_ARTIFACTS_PATH]
+
+namespace GCOV_SYM do
+
+  desc 'Run code coverage for all tests'
+  task all: [:prepare] do
+    @ceedling[:test_invoker].setup_and_invoke( tests:COLLECTION_ALL_TESTS, context:GCOV_SYM, options:TOOL_COLLECTION_GCOV_TASKS )
+  end
+
+  desc 'Run single test w/ coverage ([*] test or source file name, no path).'
+  task :* do
+    message = "Oops! '#{GCOV_ROOT_NAME}:*' isn't a real task. " \
+              "Use a real test or source file name (no path) in place of the wildcard.\n" \
+              "Example: `ceedling #{GCOV_ROOT_NAME}:foo.c`"
+
+    @ceedling[:loginator].log( message, Verbosity::ERRORS )
+  end
+
+  desc 'Run tests by matching regular expression pattern.'
+  task :pattern, [:regex] => [:prepare] do |_t, args|
+    matches = []
+
+    COLLECTION_ALL_TESTS.each do |test|
+      matches << test if test =~ /#{args.regex}/
+    end
+
+    if !matches.empty?
+      @ceedling[:test_invoker].setup_and_invoke( tests:matches, context:GCOV_SYM, options:{ force_run: false }.merge(TOOL_COLLECTION_GCOV_TASKS) )
+    else
+      @ceedling[:loginator].log("\nFound no tests matching pattern /#{args.regex}/.")
+    end
+  end
+
+  desc 'Run tests whose test path contains [dir] or [dir] substring.'
+  task :path, [:dir] => [:prepare] do |_t, args|
+    matches = []
+
+    COLLECTION_ALL_TESTS.each do |test|
+      matches << test if File.dirname(test).include?(args.dir.tr('\\', '/'))
+    end
+
+    if !matches.empty?
+      @ceedling[:test_invoker].setup_and_invoke( tests:matches, context:GCOV_SYM, options:{ force_run: false }.merge(TOOL_COLLECTION_GCOV_TASKS) )
+    else
+      @ceedling[:loginator].log( 'Found no tests including the given path or path component', Verbosity::ERRORS )
+    end
+  end
+
+  # Use a rule to increase efficiency for large projects
+  rule(/^#{GCOV_TASK_ROOT}\S+$/ => [ # gcov test tasks by regex
+     proc do |task_name|
+        # Yield clean test name => Strip the task string, remove Rake test task prefix, and remove any code file extension
+        test = task_name.strip().sub(/^#{GCOV_TASK_ROOT}/, '').chomp( EXTENSION_SOURCE )
+
+        # Ensure the test name begins with a test name prefix
+        test = PROJECT_TEST_FILE_PREFIX + test if not (test.start_with?( PROJECT_TEST_FILE_PREFIX ))
+
+        # Provide the filepath for the target test task back to the Rake task
+        @ceedling[:file_finder].find_test_file_from_name( test )
+     end
+   ]) do |test|
+    @ceedling[:rake_wrapper][:prepare].invoke
+    @ceedling[:test_invoker].setup_and_invoke( tests:[test.source], context:GCOV_SYM, options:TOOL_COLLECTION_GCOV_TASKS )
+  end
+end
+
+# If gcov config enables dedicated report generation task, create the task
+if not @ceedling[GCOV_SYM].automatic_reporting_enabled?
+namespace GCOV_REPORT_NAMESPACE_SYM do
+
+  desc "Generate reports from coverage results (Note: a #{GCOV_SYM}: task must be executed first)"
+  task GCOV_SYM do
+    @ceedling[:gcov].generate_coverage_reports()
+  end
+
+end
+end
+

data/plugins/gcov/lib/gcov.rb

@@ -0,0 +1,282 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/plugin'
+require 'ceedling/constants'
+require 'ceedling/exceptions'
+require 'gcov_constants'
+require 'gcovr_reportinator'
+require 'reportgenerator_reportinator'
+
+class Gcov < Plugin
+  
+  # `Plugin` setup()
+  def setup
+    @result_list = []
+
+    @project_config = @ceedling[:configurator].project_config_hash
+
+    # Are any reports enabled?
+    @reports_enabled = reports_enabled?( @project_config[:gcov_reports] )
+    
+    # Was a gcov: task on the command line?
+    @cli_gcov_task = @ceedling[:system_wrapper].get_cmdline().any?{|item| item.include?( GCOV_TASK_ROOT )}
+
+    # Validate the gcov tools if coverage summaries are enabled (summaries rely on the `gcov` tool)
+    # Note: This gcov tool is a different configuration than the gcov tool used by ReportGenerator
+    if summaries_enabled?( @project_config )
+      @ceedling[:tool_validator].validate(
+        tool: TOOLS_GCOV_SUMMARY,
+        boom: true
+      )
+    end
+
+    # Validate configuration and tools while building Reportinators
+    @reportinators = build_reportinators( 
+      @project_config[:gcov_utilities],
+      @reports_enabled,
+      @cli_gcov_task
+    )
+
+    # Convenient instance variable references
+    @configurator = @ceedling[:configurator]
+    @loginator = @ceedling[:loginator]
+    @test_invoker = @ceedling[:test_invoker]
+    @plugin_reportinator = @ceedling[:plugin_reportinator]
+    @file_path_utils = @ceedling[:file_path_utils]
+    @file_wrapper = @ceedling[:file_wrapper]
+    @tool_executor = @ceedling[:tool_executor]
+
+    @mutex = Mutex.new()
+  end
+
+  # Called within class and also externally by plugin Rakefile
+  # No parameters enables the opportunity for latter mechanism
+  def automatic_reporting_enabled?
+    return (@project_config[:gcov_report_task] == false)
+  end
+
+  def pre_compile_execute(arg_hash)
+    if arg_hash[:context] == GCOV_SYM
+      source = arg_hash[:source]
+
+      # If a source file (not unity, mocks, etc.) is to be compiled use code coverage compiler
+      if (File.extname(source) != EXTENSION_ASSEMBLY) && @configurator.collection_all_source.include?(source)
+        arg_hash[:tool] = TOOLS_GCOV_COMPILER
+        arg_hash[:msg] = "Compiling #{File.basename(source)} with coverage..."
+      end
+    end
+  end
+
+  def pre_link_execute(arg_hash)
+    if arg_hash[:context] == GCOV_SYM
+      arg_hash[:tool] = TOOLS_GCOV_LINKER
+    end
+  end
+
+  # `Plugin` build step hook
+  def post_test_fixture_execute(arg_hash)
+    result_file = arg_hash[:result_file]
+
+    @mutex.synchronize do
+      if (result_file =~ /#{GCOV_RESULTS_PATH}/) && !@result_list.include?(result_file)
+        @result_list << arg_hash[:result_file]
+      end
+    end
+  end
+
+  # `Plugin` build step hook
+  def post_build
+    # Do nothing unless a gcov: task was on the command line
+    return unless @cli_gcov_task
+
+    # Only present plugin-based test results if raw test results disabled by a reporting plugin
+    if !@configurator.plugins_display_raw_test_results
+      results = {}
+
+      # Assemble test results
+      @mutex.synchronize do
+        results = @plugin_reportinator.assemble_test_results( @result_list )
+      end
+
+      hash = {
+        header: GCOV_ROOT_NAME.upcase,
+        results: results
+      }
+
+      # Print unit test suite results
+      @plugin_reportinator.run_test_results_report( hash ) do
+        message = ''
+        message = 'Unit test failures.' if results[:counts][:failed] > 0
+        message
+      end
+    end
+
+    # Print summary of coverage to console for each source file exercised by a test
+    console_coverage_summaries() if summaries_enabled?( @project_config )
+
+    # Run full coverage report generation
+    generate_coverage_reports() if automatic_reporting_enabled?
+  end
+
+  # `Plugin` build step hook
+  def summary
+    # Only present plugin-based test results if raw test results disabled by a reporting plugin
+    return if @configurator.plugins_display_raw_test_results
+
+    # Build up the list of passing results from all tests
+    result_list = @file_path_utils.form_pass_results_filelist(
+      GCOV_RESULTS_PATH,
+      COLLECTION_ALL_TESTS
+    )
+
+    hash = {
+      header: GCOV_ROOT_NAME.upcase,
+      # Collect all existing test results (success or failing) in the filesystem,
+      # limited to our test collection
+      :results => @plugin_reportinator.assemble_test_results(
+        result_list,
+        {:boom => false}
+      )
+    }
+
+    @plugin_reportinator.run_test_results_report(hash)
+  end
+
+  # Called within class and also externally by conditionally regnerated Rake task
+  # No parameters enables the opportunity for latter mechanism
+  def generate_coverage_reports()
+    return if not @reports_enabled
+
+    @reportinators.each do |reportinator|
+      # Create the artifacts output directory.
+      @file_wrapper.mkdir( reportinator.artifacts_path )
+
+      # Generate reports
+      reportinator.generate_reports( @configurator.project_config_hash )
+    end
+  end
+
+  ### Private ###
+
+  private
+
+  def reports_enabled?(cfg_reports)
+    return !cfg_reports.empty?
+  end
+
+  def summaries_enabled?(config)
+    return config[:gcov_summaries]
+  end
+
+  def utility_enabled?(opts, utility_name)
+    return opts.map(&:upcase).include?( utility_name.upcase )
+  end
+
+  def console_coverage_summaries()
+    banner = @plugin_reportinator.generate_banner( "#{GCOV_ROOT_NAME.upcase}: CODE COVERAGE SUMMARY" )
+    @loginator.log "\n" + banner
+
+    # Iterate over each test run and its list of source files
+    @test_invoker.each_test_with_sources do |test, sources|
+      heading = @plugin_reportinator.generate_heading( test )
+      @loginator.log(heading)
+
+      sources.each do |source|
+        filename = File.basename(source)
+        name     = filename.ext('')
+        command  = @tool_executor.build_command_line(
+                     TOOLS_GCOV_SUMMARY,
+                     [], # No additional arguments
+                     filename, # .c source file that should have been compiled with coverage
+                     File.join(GCOV_BUILD_OUTPUT_PATH, test) # <build>/gcov/out/<test name> for coverage data files
+                   )
+
+        # Do not raise an exception if `gcov` terminates with a non-zero exit code, just note it and move on.
+        # Recent releases of `gcov` have become more strict and vocal about errors and exit codes.
+        command[:options][:boom] = false
+
+        # Run the gcov tool and collect the raw coverage report
+        shell_results  = @tool_executor.exec( command )
+        results        = shell_results[:output].strip
+
+        # Handle errors instead of raising a shell exception
+        if shell_results[:exit_code] != 0
+          debug = "gcov error (#{shell_results[:exit_code]}) while processing #{filename}... #{results}"
+          @loginator.log( debug, Verbosity::DEBUG, LogLabels::ERROR )
+          @loginator.log( "gcov was unable to process coverage for #{filename}", Verbosity::COMPLAIN )
+          next # Skip to next loop iteration
+        end
+
+        # A source component may have been compiled with coverage but none of its code actually called in a test.
+        # In this case, versions of gcov may not produce an error, only blank results.
+        if results.empty?
+          msg = "No functions called or code paths exercised by test for #{filename}"
+          @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE )
+          next # Skip to next loop iteration
+        end
+
+        # Source filepath to be extracted from gcov coverage results via regex
+        _source = ''
+
+        # Extract (relative) filepath from results and expand to absolute path
+        matches = results.match(/File\s+'(.+)'/)
+        if matches.nil? or matches.length() != 2
+          msg = "Could not extract filepath via regex from gcov results for #{test}::#{File.basename(source)}"
+          @loginator.log( msg, Verbosity::DEBUG, LogLabels::ERROR )
+        else
+          # Expand to full path from likely partial path to ensure correct matches on source component within gcov results
+          _source = File.expand_path(matches[1])
+        end
+
+        # If gcov results include intended source (comparing absolute paths), report coverage details summaries
+        if _source == File.expand_path(source)
+          # Reformat from first line as filename banner to each line of statistics labeled with the filename
+          # Only extract the first four lines of the console report (to avoid spidering coverage reports through libs, etc.)
+          report = results.lines.to_a[1..4].map { |line| filename + ' | ' + line }.join('')
+          @loginator.log(report + "\n")
+        
+        # Otherwise, found no coverage results
+        else
+          msg = "Found no coverage results for #{test}::#{File.basename(source)}"
+          @loginator.log( msg, Verbosity::COMPLAIN )
+        end
+      end
+    end
+  end
+
+  def build_reportinators(config, enabled, gcov_task)
+    reportinators = []
+
+    # Do not instantiate reportinators (and tool validation) unless reports enabled and a gcov: task present in command line
+    return reportinators if ((!enabled) or (!gcov_task))
+
+    config.each do |reportinator|
+      if not GCOV_UTILITY_NAMES.map(&:upcase).include?( reportinator.upcase )
+        options = GCOV_UTILITY_NAMES.map{ |utility| "'#{utility}'" }.join(', ')
+        msg = "Plugin configuration :gcov ↳ :utilities => `#{reportinator}` is not a recognized option {#{options}}."
+        raise CeedlingException.new(msg)
+      end
+    end
+
+    # Run reports using gcovr
+    if utility_enabled?( config, GCOV_UTILITY_NAME_GCOVR )
+      reportinator = GcovrReportinator.new( @ceedling )
+      reportinators << reportinator
+    end
+
+    # Run reports using ReportGenerator
+    if utility_enabled?( config, GCOV_UTILITY_NAME_REPORT_GENERATOR )
+      reportinator = ReportGeneratorReportinator.new( @ceedling )
+      reportinators << reportinator
+    end
+
+    return reportinators
+  end
+
+end
+

data/plugins/gcov/lib/gcov_constants.rb

@@ -0,0 +1,63 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+GCOV_ROOT_NAME                  = 'gcov'.freeze
+GCOV_TASK_ROOT                  = GCOV_ROOT_NAME + ':'
+GCOV_SYM                        = GCOV_ROOT_NAME.to_sym
+
+GCOV_REPORT_NAMESPACE           = 'report'.freeze
+GCOV_REPORT_NAMESPACE_SYM       = GCOV_REPORT_NAMESPACE.to_sym
+
+GCOV_BUILD_PATH                 = File.join(PROJECT_BUILD_ROOT, GCOV_ROOT_NAME)
+GCOV_BUILD_OUTPUT_PATH          = File.join(GCOV_BUILD_PATH, "out")
+GCOV_RESULTS_PATH               = File.join(GCOV_BUILD_PATH, "results")
+GCOV_DEPENDENCIES_PATH          = File.join(GCOV_BUILD_PATH, "dependencies")
+GCOV_ARTIFACTS_PATH             = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, GCOV_ROOT_NAME)
+
+GCOV_REPORT_GENERATOR_ARTIFACTS_PATH  = File.join(GCOV_ARTIFACTS_PATH, "ReportGenerator")
+GCOV_GCOVR_ARTIFACTS_PATH             = File.join(GCOV_ARTIFACTS_PATH, "gcovr")
+
+GCOV_GCOVR_ARTIFACTS_FILE_HTML        = File.join(GCOV_GCOVR_ARTIFACTS_PATH, "GcovCoverageResults.html")
+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
+}
+
+# Report Creation Utilities
+GCOV_UTILITY_NAME_GCOVR = "gcovr"
+GCOV_UTILITY_NAME_REPORT_GENERATOR = "ReportGenerator"
+GCOV_UTILITY_NAMES = [GCOV_UTILITY_NAME_GCOVR, GCOV_UTILITY_NAME_REPORT_GENERATOR]
+
+# Report Types
+class ReportTypes
+  HTML_BASIC = "HtmlBasic"
+  HTML_DETAILED = "HtmlDetailed"
+  HTML_CHART = "HtmlChart"
+  HTML_INLINE = "HtmlInline"
+  HTML_INLINE_AZURE = "HtmlInlineAzure"
+  HTML_INLINE_AZURE_DARK = "HtmlInlineAzureDark"
+  MHTML = "MHtml"
+  TEXT = "Text"
+  COBERTURA = "Cobertura"
+  SONARQUBE = "SonarQube"
+  JSON = "JSON"
+  BADGES = "Badges"
+  CSV_SUMMARY = "CsvSummary"
+  LATEX = "Latex"
+  LATEX_SUMMARY = "LatexSummary"
+  PNG_CHART = "PngChart"
+  TEAM_CITY_SUMMARY = "TeamCitySummary"
+  LCOV = "lcov"
+  XML = "Xml"
+  XML_SUMMARY = "XmlSummary"
+end