ceedling 1.1.9 → 1.2.0

data/plugins/report_tests_pretty_stdout/assets/{template.erb → test_results.template}

@@ -1,8 +1,8 @@
-% ignored        = hash[:results][:counts][:ignored]
-% failed         = hash[:results][:counts][:failed]
-% stdout_count   = hash[:results][:counts][:stdout]
-% header_prepend = ((hash[:context] != TEST_SYM) ? "#{hash[:context].to_s.upcase}: " : '')
-% banner_width   = 25 + header_prepend.length # widest message
+% preamble       = @ceedling[:plugin_reportinator].test_report_preamble(hash)
+% ignored        = preamble[:ignored]
+% failed         = preamble[:failed]
+% stdout_count   = preamble[:stdout_count]
+% header_prepend = preamble[:header_prepend]
 
 % if (stdout_count > 0)
 <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'TEST OUTPUT')%>
@@ -38,7 +38,7 @@
   Test: <%=item[:test]%>
 %       if (not item[:message].empty?)
 %         # Cause multline error messages to wrap with indentation aligned with line header
-%         msg = item[:message].split("\n").enum_for(:each_with_index).map{|line,i| ((i >= 1) ? (' ' * (header.size + 3)) : '') + line}.join("\n")
+%         msg = @ceedling[:plugin_reportinator].reflow_message(item[:message], ' ' * (header.size + 3))
   <%=header%> "<%=msg%>"
 %       else
   <%=header%>
@@ -49,8 +49,8 @@
 % end
 % total_string = hash[:results][:counts][:total].to_s
 % format_string = "%#{total_string.length}i"
-% decorator = (failed > 0) ? LogLabels::FAIL : LogLabels::PASS
-<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + @loginator.decorate('OVERALL TEST SUMMARY', decorator))%>
+% banner_text = @ceedling[:plugin_reportinator].decorate_summary_banner('OVERALL TEST SUMMARY', failed)
+<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + banner_text)%>
 % if (hash[:results][:counts][:total] > 0)
 TESTED:  <%=hash[:results][:counts][:total].to_s%>
 PASSED:  <%=sprintf(format_string, hash[:results][:counts][:passed])%>

data/plugins/report_tests_raw_output_log/lib/report_tests_raw_output_log.rb

@@ -5,31 +5,28 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'ceedling/plugins/plugin'
+require 'ceedling/plugins/report_log_writer_plugin'
 require 'ceedling/constants'
 
-class ReportTestsRawOutputLog < Plugin
+class ReportTestsRawOutputLog < ReportLogWriterPlugin
   # `Plugin` setup()
   def setup
-   # @raw_output hash with default values
-    @raw_output = {}
-
-    # Ceedling can run with multiple threads, provide a lock to use around @raw_output
-    @mutex = Mutex.new()
+    super
 
-    # Convenient instance variable references
-    @file_wrapper = @ceedling[:file_wrapper]
-    @loginator = @ceedling[:loginator]
-    @reportinator = @ceedling[:reportinator]
+    # @raw_output hash with default values
+    @raw_output = {}
   end
 
   # `Plugin` build step hook
   def post_test_fixture_execute(arg_hash)
+    # A test reported from cached results was not run, so it printed nothing
+    return if arg_hash[:shell_result].nil?
+
     output = extract_output( arg_hash[:shell_result][:output] )
 
     # Bail out early
     return if output.empty?
-    
+
     # After test fixture execution, parse output, store any raw console statements
     @mutex.synchronize do
       process_output(
@@ -63,13 +60,13 @@ class ReportTestsRawOutputLog < Plugin
 
     raw_output.each_line do |line|
       # Skip blank lines
-      next if line =~ /^\s*\n$/
+      next if line.match?(/^\s*\n$/)
 
       # Skip test case reporting lines
-      next if line =~ /^.+:\d+:.+:(IGNORE|PASS|FAIL)/
+      next if line.match?(/^.+:\d+:.+:(IGNORE|PASS|FAIL)/)
 
       # Return early if we get to test results summary footer
-      return output if line =~/^-+\n$/
+      return output if line.match?(/^-+\n$/)
 
       # Capture all other console output from the test runner, including `printf()`-style debugging statements
       output << line
@@ -86,44 +83,17 @@ class ReportTestsRawOutputLog < Plugin
   end
 
   def write_logs(hash)
-    msg = @reportinator.generate_heading( "Running Raw Tests Output Report" )
-    @loginator.log( msg )
-
-    empty = false
-
-    @mutex.synchronize { empty = hash.empty? }
-
-    if empty
-      @loginator.log( "Tests produced no extra console output.\n" )
-      return
-    end
-
-    @mutex.synchronize do
+    flush_log(
+      heading: 'Running Raw Tests Output Report',
+      empty_message: 'Tests produced no extra console output.',
+      empty: -> { hash.empty? }
+    ) do
       hash.each do |context, tests|
         tests.each do |test, output|
-          log_filepath = form_log_filepath( context, test )
-
-          msg = @reportinator.generate_progress( "Generating artifact #{log_filepath}" )
-          @loginator.log( msg )
-
-          File.open( log_filepath, 'w' ) do |f|
-            output.each { |line| f << line }
-          end
+          write_artifact(artifact_filepath(context, "#{test}.raw.log"), output.join)
         end
       end
     end
-
-    # White space at command line after progress messages
-    @loginator.log( '' )
   end
 
-  def form_log_filepath(context, test)
-    path = File.join( PROJECT_BUILD_ARTIFACTS_ROOT, context.to_s )
-    filepath = File.join(path, test + '.raw.log')
-
-    # Ensure containing artifact directory exists
-    @file_wrapper.mkdir( path )
-
-    return filepath
-  end
 end

data/plugins/report_tests_teamcity_stdout/lib/report_tests_teamcity_stdout.rb

@@ -27,6 +27,12 @@ class ReportTestsTeamcityStdout < Plugin
     # This hash relates each test filepath to a unique Flow ID
     # (TeamCity uses Flow IDs to differentiate messages generated in concurrent threads)
     @suites = {}
+
+    # Captured rather than called as a bare `puts` so a test can substitute
+    # a StringIO -- deliberately not routed through Loginator, which would
+    # risk both suppression under a quiet --verbosity and batching/timing
+    # changes to what TeamCity expects as immediate, real-time messages.
+    @stream = $stdout
   end
 
   # `Plugin` build step hook
@@ -152,12 +158,17 @@ class ReportTestsTeamcityStdout < Plugin
 
   def escape(string)
     # https://www.jetbrains.com/help/teamcity/service-messages.html#Escaped+Values
-    string.gsub(/['|\[\]]/, '|\0').gsub('\r', '|r').gsub('\n', '|n')
+    # A real embedded CR/LF must become the two-character |r/|n sequence, not
+    # pass through as an actual line break -- TeamCity parses service
+    # messages one physical line at a time, so an unescaped newline mid
+    # message would split it across lines and corrupt the message TeamCity
+    # sees.
+    string.gsub(/['|\[\]]/, '|\0').gsub("\r", '|r').gsub("\n", '|n')
   end
 
   def teamcity_service_message(content, flowId=0)
     # https://www.jetbrains.com/help/teamcity/service-messages.html
-    puts "##teamcity[#{content} flowId='#{flowId}']"
+    @stream.puts "##teamcity[#{content} flowId='#{flowId}']"
   end
 
 end

data/plugins/sanitize/config/defaults.yml

@@ -0,0 +1,44 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+---
+:plugins:
+  :test_build_contexts:
+    - :sanitize   # Its :defines and :flags work as :test's do, matchers included
+
+:sanitize:
+  # Any of :address, :undefined, and :leak. ASan's runtime checks leaks too.
+  :sanitizers:
+    - :address
+    - :undefined
+
+  # Keep running after a finding rather than halting the test at the first one
+  :recover: FALSE
+
+  # Check for leaks at exit where the platform supports it (Linux)
+  :detect_leaks: TRUE
+
+  # Also instrument ordinary test: builds, not only sanitize: builds
+  :test_builds: FALSE
+
+  # Register a build failure when any sanitizer reports a finding
+  :fail_build: TRUE
+
+  # Any of :text, :json, and :sarif; none is the text log alone
+  :reports: []
+
+  # Extra runtime options for each sanitizer, e.g. :asan: [strict_string_checks=1]
+  :runtime_options:
+    :asan: []
+    :ubsan: []
+    :lsan: []
+
+  # Extra compile and link flags for instrumented builds
+  :flags:
+    :compile: []
+    :link: []
+...

data/plugins/sanitize/config/defaults_sanitize.rb

@@ -0,0 +1,20 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Runs a test executable with each sanitizer's runtime options set for it alone
+DEFAULT_SANITIZE_FIXTURE_TOOL = {
+    :executable => 'env'.freeze,
+    :name => 'default_sanitize_fixture'.freeze,
+    :optional => true.freeze,
+    :arguments => [].freeze  # Option settings and the test executable come from the plugin
+    }
+
+def get_default_config
+    return :tools => {
+        :sanitize_fixture => DEFAULT_SANITIZE_FIXTURE_TOOL
+    }
+end

data/plugins/sanitize/lib/sanitize.rb

@@ -0,0 +1,174 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/plugins/plugin'
+require 'ceedling/constants'
+require 'ceedling/exceptions'
+require 'version'
+require 'sanitize_constants'
+require 'sanitize_config'
+require 'sanitize_findings'
+require 'sanitize_reports'
+require 'sanitize_records'
+
+# Builds and runs test executables with ASan, UBSan, and LeakSanitizer. A sanitize: build
+# is instrumented, and ordinary test: builds are too when :test_builds asks. No other
+# plugin's build is ever instrumented.
+class Sanitize < Plugin
+
+  # `Plugin` setup(). Checks only settings, since it runs for every command the plugin is
+  # enabled for. The platform and tools are checked by validate_environment!.
+  def setup
+    @configurator        = @ceedling[:configurator]
+    @loginator           = @ceedling[:loginator]
+    @dependinator        = @ceedling[:dependinator]
+    @plugin_reportinator = @ceedling[:plugin_reportinator]
+    @system_wrapper      = @ceedling[:system_wrapper]
+
+    read_settings( @ceedling[:setupinator].config_hash[:sanitize] )
+
+    @result_list = []
+    @mutex       = Mutex.new
+  end
+
+  # Called by the plugin Rakefile's :sanitize_deps task, which every sanitize: task depends
+  # on, so a project only enabling the plugin can still build where sanitizers can't run.
+  # Memoized.
+  def validate_environment!
+    return if @environment_validated
+
+    if @system_wrapper.windows?
+      raise CeedlingException.new( "The sanitize plugin is not supported on Windows.\n" \
+                                   "Remove `sanitize` from :plugins ↳ :enabled, or run sanitize: builds on Linux or macOS." )
+    end
+
+    @ceedling[:tool_validator].validate( tool: TOOLS_SANITIZE_FIXTURE, boom: true )
+    @settings.notices.each { |notice| @loginator.log( notice, Verbosity::COMPLAIN ) }
+    @environment_validated = true
+  end
+
+  # An instrumented test: build runs through no sanitize: task, so it checks here, once,
+  # before any test builds
+  def pre_test_build(context, _timestamp_s)
+    validate_environment! if instrumented?( context )
+  end
+
+  def pre_test_compile_register(arg_hash)
+    return unless instrumented?( arg_hash[:context] )
+    return if EXTENSION_ASSEMBLY.match?( arg_hash[:source] )
+
+    arg_hash[:flags] += @settings.compile_flags
+    @dependinator.register( arg_hash[:object], meta: { sanitize: @build_settings } )
+  end
+
+  def pre_test_link_register(arg_hash)
+    return unless instrumented?( arg_hash[:context] )
+
+    arg_hash[:flags] += @settings.link_flags
+    @dependinator.register( arg_hash[:executable], meta: { sanitize: @build_settings } )
+  end
+
+  # Runs the fixture tool, the project's own or Ceedling's, with each sanitizer's runtime
+  # options set for it alone. Backtrace reruns go through it too, so they run the same way.
+  def pre_test_fixture_register(arg_hash)
+    return unless instrumented?( arg_hash[:context] )
+
+    fixture = arg_hash[:tool]
+    # Single-quoted, so the shell running the fixture command passes each value through as
+    # written. A single quote within a value ends the quoting, is escaped, and resumes it.
+    options = @settings.environment.map { |variable, value| "#{variable}='#{value.gsub( "'" ) { %q('\\'') }}'" }
+    arguments = options + [fixture[:executable]] + Array( fixture[:arguments] )
+
+    arg_hash[:tool] = TOOLS_SANITIZE_FIXTURE.merge( arguments: arguments, backtrace_rerun: true )
+    @dependinator.register( arg_hash[:target], meta: { sanitize: @build_settings } )
+  end
+
+  # Findings come from the fixture's stderr, where every sanitizer reports. A test reported
+  # from cached results was not run and has none.
+  def post_test_fixture_execute(arg_hash)
+    return unless instrumented?( arg_hash[:context] )
+    return if arg_hash[:shell_result].nil?
+
+    collect_result( arg_hash )
+
+    findings = SanitizeFindings.parse( arg_hash[:shell_result][:stderr] )
+    return if findings.empty?
+
+    @records.record( arg_hash[:context], arg_hash[:test_name], findings )
+  end
+
+  # A crash a sanitizer stopped is named by its first finding. A backtrace rerun can reach a
+  # finding the main run never did, so the findings it explains are recorded too.
+  def explain_test_crash(arg_hash)
+    return unless instrumented?( arg_hash[:context] )
+
+    findings = SanitizeFindings.parse( arg_hash[:shell_result][:stderr] )
+    return if findings.empty?
+
+    @records.record( arg_hash[:context], arg_hash[:test_name], findings, explained: (findings.first if arg_hash[:crash_notice]) )
+    arg_hash.merge!( SanitizeRecords.explanation( arg_hash[:context], arg_hash[:test_name], findings.first ) )
+  end
+
+  def post_build(_timestamp_s)
+    contexts = reported_contexts
+    return if contexts.empty?
+
+    report_test_results if contexts.include?( SANITIZE_SYM )
+    contexts.each { |context| @records.write_reports( context ) }
+
+    @ceedling[:plugin_manager].register_build_failure( SANITIZE_SYM, @records.failure_message ) if @settings.fail_build && !@records.empty?
+  end
+
+  ### Private ###
+
+  private
+
+  # Only the settings that change what a build or test run produces are dependency meta, so
+  # changing how findings are reported rebuilds nothing
+  def read_settings(config)
+    @build_settings = config.slice( :sanitizers, :recover, :detect_leaks, :runtime_options, :flags )
+    @settings = SanitizeConfig.new( config, platform: platform )
+
+    reports  = SanitizeReports.load( config[:reports], version: Ceedling::Version::TAG )
+    @records = SanitizeRecords.new( file_wrapper: @ceedling[:file_wrapper], loginator: @loginator, reports: reports )
+  end
+
+  def platform
+    return :windows if @system_wrapper.windows?
+    return :macos   if @system_wrapper.macos?
+
+    return :linux
+  end
+
+  def instrumented?(context)
+    return context == SANITIZE_SYM || (@settings.test_builds && context == TEST_SYM)
+  end
+
+  # A sanitize: build reports its own test results, apart from an ordinary test build's
+  def collect_result(arg_hash)
+    return unless arg_hash[:context] == SANITIZE_SYM
+
+    @mutex.synchronize { @result_list << arg_hash[:result_file] unless @result_list.include?( arg_hash[:result_file] ) }
+  end
+
+  # The instrumented builds this run included
+  def reported_contexts
+    contexts = []
+    contexts << SANITIZE_SYM if @ceedling[:rake_invocation_tracker].invoked?( /^#{SANITIZE_ROOT_NAME}(:|$)/ )
+    contexts << TEST_SYM if @settings.test_builds && @ceedling[:rake_invocation_tracker].invoked?( /^test(:|$)/ )
+    return contexts
+  end
+
+  # Only when a reporting plugin has disabled raw test results display
+  def report_test_results
+    return if @configurator.plugins_display_raw_test_results
+
+    results = @plugin_reportinator.assemble_test_results( @result_list )
+    @plugin_reportinator.run_test_results_report( { context: SANITIZE_SYM, results: results }, @plugin_reportinator.test_results_floor_verbosity )
+  end
+
+end

data/plugins/sanitize/lib/sanitize_config.rb

@@ -0,0 +1,110 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/exceptions'
+
+# The compile and link flags and the runtime environment a project's :sanitize settings
+# call for on a platform, checked as they are read
+class SanitizeConfig
+  attr_reader :sanitizers, :compile_flags, :link_flags, :environment, :notices, :test_builds, :fail_build
+
+  NAMES = %i[address undefined leak].freeze
+
+  # Each sanitizer's runtime options variable, keyed as :runtime_options names them
+  OPTION_VARIABLES = { asan: 'ASAN_OPTIONS', ubsan: 'UBSAN_OPTIONS', lsan: 'LSAN_OPTIONS' }.freeze
+
+  LEAKS_UNSUPPORTED = 'Leak detection is not supported on macOS and has been disabled.'.freeze
+
+  def initialize(config, platform:)
+    @config   = config
+    @platform = platform
+    @notices  = []
+
+    read_switches
+    @sanitizers = sanitizer_list
+
+    @compile_flags = compile_flags_list
+    @link_flags    = ["-fsanitize=#{instrumented.join( ',' )}"] + Array( flags[:link] )
+    @environment   = runtime_environment
+  end
+
+  private
+
+  def read_switches
+    @recover      = boolean( :recover )
+    @detect_leaks = boolean( :detect_leaks )
+    @test_builds  = boolean( :test_builds )
+    @fail_build   = boolean( :fail_build )
+  end
+
+  def flags
+    return @config[:flags] || {}
+  end
+
+  # LeakSanitizer is not supported on macOS, where ASan aborts if asked to check leaks
+  def sanitizer_list
+    names = Array( @config[:sanitizers] ).map { |entry| name( entry ) }.uniq
+    raise CeedlingException.new( ':sanitize ↳ :sanitizers names no sanitizer.' ) if names.empty?
+    return names unless @platform == :macos && (names.include?( :leak ) || (@detect_leaks && names.include?( :address )))
+
+    @notices << LEAKS_UNSUPPORTED
+    return names - [:leak]
+  end
+
+  def name(entry)
+    sanitizer = entry.to_s.downcase.to_sym
+    return sanitizer if (entry.is_a?( String ) || entry.is_a?( Symbol )) && NAMES.include?( sanitizer )
+
+    choices = NAMES.map( &:inspect ).join( ', ' )
+    raise CeedlingException.new( ":sanitize ↳ :sanitizers entry `#{entry}` is not a supported sanitizer. Choose from #{choices}." )
+  end
+
+  # ASan's runtime includes leak detection, so leaks need their own sanitizer only alone
+  def instrumented
+    return @sanitizers.include?( :address ) ? @sanitizers - [:leak] : @sanitizers
+  end
+
+  def compile_flags_list
+    halting = @recover ? [] : ['-fno-sanitize-recover=all']
+    return ["-fsanitize=#{instrumented.join( ',' )}"] + halting + ['-fno-omit-frame-pointer', '-g'] + Array( flags[:compile] )
+  end
+
+  # Findings come from each report, not from the exit code, so a sanitizer exits 0 and only
+  # Unity's own exit code remains. A halt leaves Unity's summary missing, which reads as a
+  # crash. A leak checked at exit leaves a clean summary.
+  def runtime_environment
+    return base_options.to_h { |key, values| [OPTION_VARIABLES[key], (values + Array( runtime_options[key] )).join( ':' )] }
+  end
+
+  def base_options
+    halt = "halt_on_error=#{@recover ? 0 : 1}"
+    options = {}
+    options[:asan]  = [halt, 'exitcode=0'] + leak_option if @sanitizers.include?( :address )
+    options[:ubsan] = [halt, 'print_stacktrace=1', 'exitcode=0'] if @sanitizers.include?( :undefined )
+    options[:lsan]  = ['exitcode=0'] if instrumented.include?( :leak )
+    return options
+  end
+
+  def leak_option
+    return [] if @platform == :macos
+
+    return ["detect_leaks=#{@detect_leaks ? 1 : 0}"]
+  end
+
+  def runtime_options
+    return @config[:runtime_options] || {}
+  end
+
+  # A quoted 'false' would otherwise read as true
+  def boolean(key)
+    value = @config[key]
+    return value if [true, false].include?( value )
+
+    raise CeedlingException.new( ":sanitize ↳ :#{key} must be TRUE or FALSE, not `#{value.inspect}`." )
+  end
+
+end

data/plugins/sanitize/lib/sanitize_constants.rb

@@ -0,0 +1,13 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+SANITIZE_ROOT_NAME              = 'sanitize'.freeze
+SANITIZE_TASK_ROOT              = SANITIZE_ROOT_NAME + ':'
+SANITIZE_SYM                    = SANITIZE_ROOT_NAME.to_sym unless defined?(SANITIZE_SYM)
+
+SANITIZE_BUILD_PATH             = File.join(PROJECT_BUILD_ROOT, SANITIZE_ROOT_NAME)
+SANITIZE_ARTIFACTS_PATH         = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, SANITIZE_ROOT_NAME)

data/plugins/sanitize/lib/sanitize_findings.rb

@@ -0,0 +1,85 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Reads sanitizer reports out of a test executable's stderr. Each report becomes a finding,
+# located at the first stack frame in the program rather than in the sanitizer's runtime.
+module SanitizeFindings
+
+  Finding = Struct.new( :sanitizer, :kind, :file, :line, :column, :message, :text, keyword_init: true )
+
+  # The first line of each kind of report
+  ASAN_ERROR = /==\d+==ERROR: AddressSanitizer: (\S+)(.*)$/
+  LSAN_ERROR = /==\d+==ERROR: LeakSanitizer: detected memory leaks/
+  UBSAN_ERROR = /^(.+?):(\d+):(\d+): runtime error: (.+)$/
+
+  ASAN_SUMMARY = /^SUMMARY: AddressSanitizer: \S+ (.+?):(\d+)(?::\d+)? in /
+  LEAK_LINE    = /^((?:Direct|Indirect) leak of .+?)(?: allocated from:)?\s*$/
+  FRAME        = /^\s+#\d+ 0x\h+ in \S+ (.+?):(\d+)(?::\d+)?\s*$/
+
+  # Frames in the sanitizer runtime and the C library rather than the program
+  RUNTIME_FRAME = %r{libsanitizer|compiler-rt|libclang_rt|/sysdeps/|/csu/}
+
+  def self.parse(stderr)
+    return reports( stderr.to_s.lines ).map { |lines| finding( lines ) }
+  end
+
+  # Splits the lines into one group per report, each starting at its first line
+  def self.reports(lines)
+    groups = []
+    lines.each do |line|
+      groups << [] if report_start?( line )
+      groups.last << line unless groups.empty?
+    end
+    return groups
+  end
+
+  def self.report_start?(line)
+    return line.match?( ASAN_ERROR ) || line.match?( LSAN_ERROR ) || line.match?( UBSAN_ERROR )
+  end
+
+  def self.finding(lines)
+    first = lines.first
+    return leak( lines ) if first.match?( LSAN_ERROR )
+    return address( lines, first.match( ASAN_ERROR ) ) if first.match?( ASAN_ERROR )
+
+    return undefined( lines, first.match( UBSAN_ERROR ) )
+  end
+
+  # The summary line names the error's location. Without one, the first program frame does.
+  def self.address(lines, error)
+    summary = lines.lazy.filter_map { |line| line.match( ASAN_SUMMARY ) }.first
+    file, line = summary ? [summary[1], summary[2].to_i] : program_frame( lines )
+
+    return Finding.new(
+      sanitizer: :address, kind: error[1], file: file, line: line, message: "#{error[1]}#{error[2]}".strip, text: lines.join
+    )
+  end
+
+  # A leak is located where its first leaked object was allocated
+  def self.leak(lines)
+    leaked = lines.index { |line| line.match?( LEAK_LINE ) }
+    file, line = program_frame( leaked ? lines.drop( leaked ) : lines )
+    message = leaked ? lines[leaked].match( LEAK_LINE )[1] : 'detected memory leaks'
+
+    return Finding.new( sanitizer: :leak, kind: 'memory-leak', file: file, line: line, message: message, text: lines.join )
+  end
+
+  def self.undefined(lines, error)
+    return Finding.new(
+      sanitizer: :undefined, kind: 'undefined-behavior', file: error[1], line: error[2].to_i, column: error[3].to_i,
+      message: error[4].strip, text: lines.join
+    )
+  end
+
+  def self.program_frame(lines)
+    frame = lines.lazy.filter_map { |line| line.match( FRAME ) }.reject { |match| match[1].match?( RUNTIME_FRAME ) }.first
+    return frame ? [frame[1], frame[2].to_i] : [nil, nil]
+  end
+
+  private_class_method :reports, :report_start?, :finding, :address, :leak, :undefined, :program_frame
+
+end