ceedling 1.1.10 → 1.2.0

data/plugins/report_build_warnings_log/lib/warning_collector.rb

@@ -0,0 +1,140 @@
+# =========================================================================
+#   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 warnings in one build step's tool output, each with the context lines that explain
+# it.
+#
+# GCC and Clang print each diagnostic as a `file:line: kind: message` line, preceded by
+# context such as `In function` or `In file included from` lines and followed by the
+# source line and a caret. Each such diagnostic becomes one group, and a `note:` joins the
+# group before it. A group is a warning when its diagnostic line matches a pattern, by
+# default any mention of "warning". Output in any other format is taken a line at a time.
+# Summary lines counting warnings (`2 warnings generated.`) are never warnings.
+#
+# Each warning is a Record of its full text and, for a GCC-style diagnostic, its parsed
+# location, severity, message, flag, and context lines. Output in another format has only
+# its text and message.
+#
+# A warning's identity leaves out its context lines, so a header's warning reached
+# through several files is one warning.
+class WarningCollector
+
+  Record = Struct.new( :file, :line, :column, :severity, :message, :flag, :context, :text, keyword_init: true )
+
+  DEFAULT_PATTERNS = [/warning/i].freeze
+
+  DIAGNOSTIC = /\A\S[^\n]*?:\d+(?::\d+)?:\s+(?:fatal error|error|warning|note|remark)\b/i
+  NOTE       = /\A\S[^\n]*?:\d+(?::\d+)?:\s+note\b/i
+  CONTEXT    = /\A(?:In file included from |\s+from |\S[^\n]*: (?:In (?:function|member function|instantiation)|At (?:top level|global scope)))/
+  # A diagnostic line's parts. A Windows drive letter's colon is not followed by digits, so
+  # the lazy file match passes it. The flag is a trailing bracketed option such as
+  # `[-Wunused-variable]`; other bracketed text stays in the message.
+  PARTS      = /\A(?<file>.+?):(?<line>\d+)(?::(?<column>\d+))?:\s+(?<severity>fatal error|error|warning|note|remark):?\s*
+                (?<message>.*?)(?:\s+\[(?<flag>-[^\]]+)\])?\s*\z/xi
+  SUMMARY    = /\A\d+ (?:warnings?|errors?)(?: and \d+ (?:warnings?|errors?))? generated\.\s*\z/
+
+  # Regular expressions from configured strings. An entry that is not a valid expression
+  # stops the build, naming `setting` and the entry.
+  def self.compile(entries, setting:)
+    return Array( entries ).map do |entry|
+      raise CeedlingException.new( "#{setting} entry `#{entry}` is not a string." ) unless entry.is_a?( String )
+
+      Regexp.new( entry )
+    rescue RegexpError => e
+      raise CeedlingException.new( "#{setting} entry `#{entry}` is not a valid regular expression: #{e.message}" )
+    end
+  end
+
+  # `patterns` replaces the default warning match; `excludes` drops any warning whose text
+  # matches one of them
+  def initialize(patterns: nil, excludes: [])
+    @patterns = (patterns.nil? or patterns.empty?) ? DEFAULT_PATTERNS : patterns
+    @excludes = excludes
+  end
+
+  def warnings(output)
+    return groups( output ).select { |group| warning?( group ) }.map { |group| record( group ) }.reject { |warning| excluded?( warning.text ) }
+  end
+
+  # A warning without the context lines before it, for recognizing one already collected.
+  # Those lines vary with the file that included a header and with whatever GCC reported
+  # just before, as its `At top level` line does; the diagnostic line itself names where
+  # the warning is.
+  def identity(warning)
+    return warning.text.lines.reject { |line| line.match?( CONTEXT ) }.join
+  end
+
+  private
+
+  # Diagnostics with their context, and every other line on its own. Each group's first
+  # diagnostic line, or its only line, decides whether it is a warning.
+  def groups(output)
+    state = { groups: [], context: [], open: nil }
+    output.each_line { |line| place( line, state ) }
+    return state[:groups]
+  end
+
+  # Context lines wait for the diagnostic they introduce, a diagnostic opens a group,
+  # a note or any other line joins the open group, and a summary closes it
+  def place(line, state)
+    case kind( line )
+    when :context then state[:context] << line
+    when :summary then nil
+    when :diagnostic then return open_group( line, state )
+    else return (state[:open] ? state[:open] << line : state[:groups] << [line])
+    end
+
+    state[:open] = nil
+  end
+
+  def open_group(line, state)
+    return state[:open] << line if line.match?( NOTE ) and state[:open]
+
+    state[:groups] << (state[:open] = state[:context] + [line])
+    state[:context] = []
+  end
+
+  def kind(line)
+    return :context    if line.match?( CONTEXT )
+    return :diagnostic if line.match?( DIAGNOSTIC )
+    return :summary    if line.match?( SUMMARY )
+
+    return :other
+  end
+
+  def warning?(group)
+    return @patterns.any? { |pattern| deciding( group ).match?( pattern ) }
+  end
+
+  def deciding(group)
+    return group.find { |line| line.match?( DIAGNOSTIC ) } || group.first
+  end
+
+  # A group's text, with its deciding line's parts when that line is a diagnostic
+  def record(group)
+    line  = deciding( group )
+    parts = line.match?( DIAGNOSTIC ) ? line.chomp.match( PARTS ) : nil
+    return Record.new( message: line.strip, context: [], text: group.join ) if parts.nil?
+
+    context = group.take_while { |each| each.match?( CONTEXT ) }.map( &:chomp )
+    return Record.new( **fields( parts ), context: context, text: group.join )
+  end
+
+  def fields(parts)
+    return {
+      file: parts[:file], line: parts[:line].to_i, column: parts[:column]&.to_i, severity: parts[:severity].downcase,
+      message: parts[:message], flag: parts[:flag]
+    }
+  end
+
+  def excluded?(text)
+    return @excludes.any? { |pattern| text.match?( pattern ) }
+  end
+
+end

data/plugins/report_build_warnings_log/lib/warning_reports.rb

@@ -0,0 +1,135 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'json'
+require 'ceedling/exceptions'
+
+# The reports a build context's warnings can be written as. Each renders a context's
+# warning records as a file's contents and names that file's extension. The plain text
+# log is the default; SARIF and JSON are structured reports for other tools to read.
+module WarningReports
+
+  # The tools' own output, each warning as printed. A context without warnings has no log.
+  class Text
+    def extension = 'log'
+    def write_empty? = false
+
+    def render(_context, warnings)
+      return warnings.map( &:text ).join
+    end
+  end
+
+  # Ceedling's own JSON layout: a context and its warnings' parsed fields. A context
+  # without warnings is still written, saying so.
+  class Json
+    def extension = 'json'
+    def write_empty? = true
+
+    def render(context, warnings)
+      fields = warnings.map { |warning| warning.to_h.slice( :file, :line, :column, :severity, :flag, :message, :context, :text ) }
+      return JSON.pretty_generate( { context: context.to_s, warnings: fields } ) + "\n"
+    end
+  end
+
+  # SARIF 2.1.0, the OASIS standard for static analysis results, as one run by Ceedling
+  # per build context. A context without warnings is a run with no results, which tells a
+  # code scanning service that earlier results are gone.
+  class Sarif
+    SCHEMA = 'https://json.schemastore.org/sarif-2.1.0.json'.freeze
+    LEVELS = { 'fatal error' => 'error', 'error' => 'error', 'warning' => 'warning', 'note' => 'note', 'remark' => 'note' }.freeze
+
+    def initialize(version)
+      @version = version
+    end
+
+    def extension = 'sarif'
+    def write_empty? = true
+
+    # The driver's rules are the warnings' distinct flags, which code scanning services
+    # expect to find for each result's rule
+    def render(context, warnings)
+      rules = warnings.filter_map( &:flag ).uniq.map { |flag| { id: flag } }
+      run   = {
+        tool:              { driver: { name: 'Ceedling', version: @version, informationUri: 'https://www.throwtheswitch.org/ceedling', rules: rules } },
+        automationDetails: { id: "#{context}/" },
+        results:           warnings.map { |warning| result( warning ) }
+      }
+      return JSON.pretty_generate( { '$schema': SCHEMA, version: '2.1.0', runs: [run] } ) + "\n"
+    end
+
+    private
+
+    # A warning without a parsed diagnostic is a message alone. SARIF's default level is
+    # warning, so an unknown severity leaves it out.
+    def result(warning)
+      result = {}
+      result[:ruleId]    = warning.flag if warning.flag
+      result[:level]     = LEVELS[warning.severity] if warning.severity
+      result[:message]   = { text: warning.message }
+      result[:locations] = [location( warning )] if warning.file
+      result[:properties] = { context: warning.context, text: warning.text }
+      return result
+    end
+
+    def location(warning)
+      region = { startLine: warning.line }
+      region[:startColumn] = warning.column if warning.column
+      return { physicalLocation: { artifactLocation: artifact( warning.file ), region: region } }
+    end
+
+    # A relative path is relative to the project, which SARIF names %SRCROOT%, and loses
+    # any leading `./` that would keep it from matching the project's file. An absolute
+    # path, POSIX or Windows, is a file URI.
+    def artifact(file)
+      path = file.tr( '\\', '/' ).sub( %r{\A(?:\./)+}, '' )
+      return { uri: "file://#{encode( path )}" } if path.start_with?( '/' )
+      return { uri: "file:///#{encode( path )}" } if path.match?( %r{\A[A-Za-z]:/} )
+
+      return { uri: encode( path ), uriBaseId: '%SRCROOT%' }
+    end
+
+    def encode(path)
+      return path.gsub( %r{[^A-Za-z0-9\-._~/:]} ) { |char| char.bytes.map { |byte| format( '%%%02X', byte ) }.join }
+    end
+  end
+
+  NAMES = %i[text sarif json].freeze
+
+  # The configured reports, each once, in the order given. Entries are symbols or strings
+  # in any letter case, and none configured is the text log alone.
+  def self.load(entries, version:)
+    names = Array( entries ).map { |entry| name( entry ) }.uniq
+    names = [:text] if names.empty?
+
+    return names.map do |name|
+      case name
+      when :text  then Text.new
+      when :sarif then Sarif.new( version )
+      when :json  then Json.new
+      end
+    end
+  end
+
+  # The configured filename without its extension, which each report supplies
+  def self.basename(filename)
+    return filename.delete_suffix( File.extname( filename ) )
+  end
+
+  def self.name(entry)
+    unless entry.is_a?( String ) or entry.is_a?( Symbol )
+      raise CeedlingException.new( ":report_build_warnings_log ↳ :reports entry `#{entry}` is not a symbol or string." )
+    end
+
+    name = entry.to_s.downcase.to_sym
+    return name if NAMES.include?( name )
+
+    choices = NAMES.map( &:inspect ).join( ', ' )
+    raise CeedlingException.new( ":report_build_warnings_log ↳ :reports entry `#{entry}` is not a report. Choose from #{choices}." )
+  end
+  private_class_method :name
+
+end

data/plugins/report_tests_gtestlike_stdout/assets/test_results.template

@@ -0,0 +1,3 @@
+% # GtestlikeReport (plugin lib/) builds the whole report. Gcov, Bullseye, and Valgrind render
+% # their results through this same template, so the plugin object reaches all of them.
+<%= @ceedling[:report_tests_gtestlike_stdout].gtest_report( hash ) %>

data/{spec/units/configurator_builder_spec.rb → plugins/report_tests_gtestlike_stdout/config/defaults.yml}

@@ -1,16 +1,12 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-
-#derived from test_graveyard/unit/busted/configurator_builder_test.rb
-
-require 'spec_helper'
-require 'ceedling/config/configurator_builder'
-
-describe ConfiguratorBuilder do
-	xit "is scary"
-end
+---
+:report_tests_gtestlike_stdout:
+  # Report Unity ignored tests as GTest skipped tests, or leave them out of the report
+  :ignored_as_skipped: TRUE
+...

data/plugins/report_tests_gtestlike_stdout/lib/gtestlike_report.rb

@@ -0,0 +1,168 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Translates Ceedling's aggregated test results into a GoogleTest console report.
+#
+# A Ceedling test file maps to a GTest test suite and each of its Unity test cases
+# to a GTest test. Line formats follow GoogleTest's own console printer. The report
+# reads results without altering them, since every reporting plugin receives the
+# same results.
+#
+# A Unity ignore is decided at runtime, as GoogleTest's GTEST_SKIP() is, so an
+# ignored test can report as skipped. Left out instead, it is neither listed nor
+# counted, and a file of only ignored tests has no section.
+class GtestlikeReport
+
+  # GoogleTest names a test by its suite and test name joined with a period
+  Test = Struct.new( :file, :name, :line, :message, :status, keyword_init: true ) do
+    def full_name = "#{file}.#{name}"
+  end
+
+  Section = Struct.new( :file, :tests, :duration_ms, keyword_init: true )
+
+  # Matches Unity's comparison message, e.g. "Expected 1 Was 2."
+  EXPECTATION = /Expected\s+(.*)\s+Was\s+([^\.]*)\./
+
+  # Splits a failure message into GTest's actual and expected values. Any message
+  # that is not a Unity comparison reads as a failed boolean assertion.
+  def self.expectation(message)
+    match = message.to_s.match( EXPECTATION )
+
+    return match.nil? ? ['FALSE', 'TRUE'] : [match[2], match[1]]
+  end
+
+  # GoogleTest's countable noun: singular for exactly one, plural otherwise
+  def self.count(n, singular, plural = "#{singular}s") = "#{n} #{n == 1 ? singular : plural}"
+
+  STATUS_TAGS = { ok: '[       OK ]', failed: '[  FAILED  ]', skipped: '[  SKIPPED ]' }.freeze
+
+  attr_reader :sections, :failures, :skipped
+
+  # Failures and skips are listed in suite order, as GoogleTest's summary walks its suites
+  def initialize(results, context:, ignored_as_skipped: true)
+    @context  = context
+    @sections = build_sections( results[:times], gather( results, ignored_as_skipped ) )
+    @failures, @skipped = %i[failed skipped].map { |status| all_tests.select { |test| test.status == status } }
+    @total_ms = to_ms( results.fetch( :total_time, 0 ) )
+  end
+
+  def total = all_tests.length
+
+  def passed = total - @failures.length - @skipped.length
+
+  def suite_count = @sections.length
+
+  def render
+    lines = ['']
+    lines << "Running testing tasks: #{@context.to_s.upcase}" if @context != TEST_SYM
+    lines << "[==========] Running #{tests( total )} from #{suites}."
+    lines << '[----------] Global test environment set-up.'
+    @sections.each { |section| lines.concat( section_lines( section ) ) }
+    lines.concat( total > 0 ? summary_lines : ['', 'No tests executed.'] )
+
+    return lines.join( "\n" ) + "\n"
+  end
+
+  ### Private ###
+
+  private
+
+  def tests(n) = self.class.count( n, 'test' )
+
+  def suites = self.class.count( suite_count, 'test suite' )
+
+  def to_ms(seconds) = (seconds * 1000.0).round
+
+  def all_tests = @sections.flat_map( &:tests )
+
+  def gather(results, ignored_as_skipped)
+    tests = tests_from( results[:successes], :ok ) + tests_from( results[:failures], :failed )
+
+    return ignored_as_skipped ? tests + tests_from( results[:ignores], :skipped ) : tests
+  end
+
+  def tests_from(entries, status)
+    return entries.flat_map do |entry|
+      entry[:collection].map do |item|
+        Test.new( file: entry[:source][:file], name: item[:test], line: item[:line], message: item[:message].to_s, status: status )
+      end
+    end
+  end
+
+  # Sections keep each file's first appearance in order. A file's tests arrive grouped
+  # by outcome, so each section sorts them into source order by line. Arrival order
+  # breaks ties. Durations arrive in seconds per file.
+  def build_sections(times, tests)
+    return tests.group_by( &:file ).map do |file, file_tests|
+      in_order = file_tests.each_with_index.sort_by { |test, i| [test.line.to_i, i] }.map( &:first )
+
+      Section.new( file: file, tests: in_order, duration_ms: to_ms( times.fetch( file, 0 ) ) )
+    end
+  end
+
+  # A suite closes with its total time and a blank line, as GoogleTest prints it
+  def section_lines(section)
+    heading = "#{tests( section.tests.length )} from #{section.file}"
+    lines = ["[----------] #{heading}"]
+
+    section.tests.each { |test| lines.concat( test_lines( test ) ) }
+
+    return lines.push( "[----------] #{heading} (#{section.duration_ms} ms total)", '' )
+  end
+
+  def test_lines(test)
+    lines = ["[ RUN      ] #{test.full_name}"]
+    lines.concat( failure_lines( test ) ) if test.status == :failed
+    lines.concat( skipped_lines( test ) ) if test.status == :skipped
+
+    return lines << "#{STATUS_TAGS[test.status]} #{test.full_name} (0 ms)"
+  end
+
+  # MSVC-style file(line) locations are what IDEs turn into links
+  def failure_lines(test)
+    location = "#{test.file}(#{test.line}):"
+    actual, expected = self.class.expectation( test.message )
+    lead = test.message.empty? ? "#{location} fail:" : "#{location} error: #{test.message}"
+
+    return [lead, " Actual:   #{actual}", " Expected: #{expected}"]
+  end
+
+  # GoogleTest prints a skip's location, any message, and a blank line before its result
+  def skipped_lines(test)
+    lines = ["#{test.file}(#{test.line}): Skipped"]
+    lines << test.message unless test.message.empty?
+
+    return lines << ''
+  end
+
+  # GoogleTest summarizes passed, then skipped, then failed tests, listing skips and
+  # failures only when there are any
+  def summary_lines
+    lines = [
+      '[----------] Global test environment tear-down',
+      "[==========] #{tests( total )} from #{suites} ran. (#{@total_ms} ms total)",
+      "[  PASSED  ] #{tests( passed )}."
+    ]
+    lines.concat( listing( :skipped, @skipped ) ) unless @skipped.empty?
+
+    return @failures.empty? ? lines : lines + failure_summary_lines
+  end
+
+  def listing(status, list)
+    tag = STATUS_TAGS[status]
+
+    return ["#{tag} #{tests( list.length )}, listed below:", *list.map { |test| "#{tag} #{test.full_name}" }]
+  end
+
+  # The trailer's count is right-aligned to two places, as GoogleTest's printf("%2d") does
+  def failure_summary_lines
+    count = @failures.length
+
+    return listing( :failed, @failures ).push( '', format( '%2d FAILED %s', count, count == 1 ? 'TEST' : 'TESTS' ) )
+  end
+
+end

data/plugins/report_tests_gtestlike_stdout/lib/report_tests_gtestlike_stdout.rb

@@ -5,8 +5,32 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'ceedling/exceptions'
 require 'report_tests_stdout_plugin'
+require 'gtestlike_report'
 
+# Parent class loads template from plugin assets directory and runs the reporting hooks
 class ReportTestsGtestlikeStdout < ReportTestsStdoutPlugin
-  # Parent class loads template from plugin assets directory
+
+  # `Plugin` setup()
+  def setup
+    super
+
+    # Whether Unity ignored tests report as GTest skipped tests or are left out. Only a
+    # true boolean is accepted, since a quoted 'false' would otherwise read as true.
+    @ignored_as_skipped = @ceedling[:configurator].report_tests_gtestlike_stdout_ignored_as_skipped
+
+    return if [true, false].include?( @ignored_as_skipped )
+
+    raise CeedlingException.new(
+      ":report_tests_gtestlike_stdout ↳ :ignored_as_skipped must be TRUE or FALSE, not nil."
+    )
+  end
+
+  # Renders the GTest console report for a results hash. The plugin's template calls this
+  # through its system object, so every context rendering results here gets the same report.
+  def gtest_report(hash)
+    return GtestlikeReport.new( hash[:results], context: hash[:context], ignored_as_skipped: @ignored_as_skipped ).render
+  end
+
 end

data/plugins/report_tests_ide_stdout/assets/test_results.template

@@ -0,0 +1,50 @@
+% # The plugin object writes each failed and ignored test's lines. Gcov, Bullseye, and
+% # Valgrind render their results through this same template, so they get the same lines.
+
+% 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')%>
+%   hash[:results][:stdout].each do |string|
+%     string[:collection].each do |item|
+<%=string[:source][:file]%>: "<%=item%>"
+%     end
+%   end
+
+% end
+% if (ignored > 0)
+<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'IGNORED TEST SUMMARY')%>
+%   hash[:results][:ignores].each do |ignore|
+%     ignore[:collection].each do |item|
+<%=@ceedling[:report_tests_ide_stdout].problem( ignore[:source][:file], item, :ignored )%>
+%     end
+%   end
+
+% end
+% if (failed > 0)
+<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'FAILED TEST SUMMARY')%>
+%   hash[:results][:failures].each do |failure|
+%     failure[:collection].each do |item|
+<%=@ceedling[:report_tests_ide_stdout].problem( failure[:source][:file], item, :failed )%>
+%     end
+%   end
+
+% end
+% total_string = hash[:results][:counts][:total].to_s
+% format_string = "%#{total_string.length}i"
+% 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])%>
+FAILED:  <%=sprintf(format_string, failed)%>
+IGNORED: <%=sprintf(format_string, ignored)%>
+% else
+
+No tests executed.
+% end
+

data/plugins/report_tests_ide_stdout/config/defaults.yml

@@ -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
+# =========================================================================
+
+---
+:report_tests_ide_stdout:
+  # The shape of each failed and ignored test's line. :absolute_paths has no default, so
+  # each format's own path form applies unless a project sets it.
+  :format: :gcc
+...

data/plugins/report_tests_ide_stdout/lib/ide_report_lines.rb

@@ -0,0 +1,103 @@
+# =========================================================================
+#   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 lines a report gives one failed or ignored test, each ending in a newline
+class IdeReportLines
+
+  # Each format a project can name, with the path form it gets when :absolute_paths is
+  # unset and the path forms it allows. An IDE's name stands for the gcc configuration that
+  # IDE reads.
+  PROFILES = {
+    gcc:     { format: :gcc,    absolute_paths: false, allowed: [true, false] },
+    legacy:  { format: :legacy, absolute_paths: false, allowed: [true, false] },
+    vscode:  { format: :gcc,    absolute_paths: false, allowed: [true, false] },
+    eclipse: { format: :gcc,    absolute_paths: false, allowed: [true, false] },
+    # CLion's output filters find only absolute paths
+    clion:   { format: :gcc,    absolute_paths: true,  allowed: [true] }
+  }.freeze
+
+  SEVERITIES = { failed: 'error', ignored: 'warning' }.freeze
+
+  # Unity reports a test's line but no column, and the gcc shape needs one
+  COLUMN = 1
+
+  # Sets a message's continuation lines under its test's problem in the console
+  INDENT = '    '
+
+  def self.load(config)
+    name    = profile_name( config[:format] )
+    profile = PROFILES[name]
+
+    return new( format: profile[:format], absolute_paths: absolute_paths( config[:absolute_paths], name, profile ) )
+  end
+
+  def self.profile_name(entry)
+    unless entry.is_a?( String ) or entry.is_a?( Symbol )
+      raise CeedlingException.new( ":report_tests_ide_stdout ↳ :format `#{entry.inspect}` is not a symbol or string." )
+    end
+
+    name = entry.to_s.downcase.to_sym
+    return name if PROFILES.key?( name )
+
+    choices = PROFILES.keys.map( &:inspect ).join( ', ' )
+    raise CeedlingException.new( ":report_tests_ide_stdout ↳ :format `#{entry}` is not a format. Choose from #{choices}." )
+  end
+
+  # Unset takes the format's own path form
+  def self.absolute_paths(value, name, profile)
+    return profile[:absolute_paths] if value.nil?
+    return value if profile[:allowed].include?( boolean( value ) )
+
+    raise CeedlingException.new(
+      ":report_tests_ide_stdout ↳ :absolute_paths cannot be #{value.to_s.upcase} with :format #{name.inspect}. " +
+      "Remove :absolute_paths or set it #{(!value).to_s.upcase}."
+    )
+  end
+
+  # A quoted 'true' would otherwise read as a setting it is not
+  def self.boolean(value)
+    return value if [true, false].include?( value )
+
+    raise CeedlingException.new( ":report_tests_ide_stdout ↳ :absolute_paths must be TRUE or FALSE, not `#{value.inspect}`." )
+  end
+  private_class_method :profile_name, :absolute_paths, :boolean
+
+  def initialize(format:, absolute_paths:)
+    @format         = format
+    @absolute_paths = absolute_paths
+  end
+
+  # Paths expand against the working directory, which is the project's root
+  def lines(file, item, outcome)
+    path = @absolute_paths ? File.expand_path( file ) : file
+
+    return (@format == :gcc) ? gcc( path, item, outcome ) : legacy( path, item )
+  end
+
+  private
+
+  # The shape of a GCC diagnostic, which IDEs read as a problem without configuration. The
+  # message's first line goes with the test's location, and the rest follow indented.
+  def gcc(path, item, outcome)
+    first, *rest = item[:message].each_line( chomp: true ).to_a
+    problem = [ item[:test], first ].reject { |part| part.to_s.empty? }.join( ': ' )
+
+    located = "#{path}:#{item[:line]}:#{COLUMN}: #{SEVERITIES[outcome]}: #{problem}\n"
+    return located + rest.map { |line| "#{INDENT}#{line}\n" }.join
+  end
+
+  # Every line of a message carries the test's file, line, and name, so each stays a link
+  def legacy(path, item)
+    prefix = "#{path}:#{item[:line]}:#{item[:test]}"
+    return "#{prefix}\n" if item[:message].empty?
+
+    return %(#{prefix}: "#{item[:message].each_line( chomp: true ).to_a.join( "\n#{prefix}: " )}"\n)
+  end
+
+end