ceedling 1.2.0 → 1.2.2

data/plugins/fff/spec/fff_cmock_wrapper_spec.rb

@@ -0,0 +1,128 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'tmpdir'
+require 'fileutils'
+
+repo_root = File.expand_path( '../../..', __dir__ )
+$LOAD_PATH.unshift( File.join( repo_root, 'lib' ), File.join( repo_root, 'vendor/cmock/lib' ) )
+
+require 'fff.rb'
+
+# GH #1377: A fake gets the extra includes CMock would give a mock of the same header.
+# Each example runs the wrapper Ceedling swaps in for CMock, with Ceedling's own
+# :includes default, and reads back the files it writes.
+describe FffCMockWrapper do
+
+  around(:each) do |example|
+    Dir.mktmpdir do |root|
+      @root = root
+      @header = File.join( root, 'src', 'bar.h' )
+      FileUtils.mkdir_p( File.dirname( @header ) )
+      File.write( @header, "void bar_turn_on(void);\n" )
+      example.run
+    end
+  end
+
+  def fake(options = {})
+    mock_path = File.join( @root, 'mocks' )
+    config = { :mock_prefix => 'mock_', :mock_path => mock_path, :includes => [], :verbosity => 0 }
+    FffCMockWrapper.new( config.merge( options ) ).setup_mocks( @header )
+    return {
+      :h => File.readlines( File.join( mock_path, 'mock_bar.h' ), chomp: true ),
+      :c => File.readlines( File.join( mock_path, 'mock_bar.c' ), chomp: true )
+    }
+  end
+
+  def position(lines, line)
+    index = lines.index( line )
+    expect( index ).not_to be_nil, "expected #{line.inspect} in:\n#{lines.join( "\n" )}"
+    return index
+  end
+
+  def extra_includes(lines)
+    standard = ['#include <string.h>', '#include "fff.h"', '#include "fff_unity_helper.h"', '#include "bar.h"', '#include "mock_bar.h"']
+    return lines.grep( /\A#include / ) - standard
+  end
+
+  it 'adds no includes when no setting names any' do
+    files = fake
+
+    expect( extra_includes( files[:h] ) ).to eq( [] )
+    expect( extra_includes( files[:c] ) ).to eq( [] )
+  end
+
+  it 'includes :includes_c_pre_header in the source before the fake header' do
+    files = fake( :includes_c_pre_header => ['extra_c.h'] )
+
+    expect( position( files[:c], '#include "extra_c.h"' ) ).to be < position( files[:c], '#include "mock_bar.h"' )
+  end
+
+  it 'includes :includes_c_post_header in the source after the fake header' do
+    files = fake( :includes_c_post_header => ['extra_c.h'] )
+
+    expect( position( files[:c], '#include "extra_c.h"' ) ).to be > position( files[:c], '#include "mock_bar.h"' )
+  end
+
+  it 'includes :includes_h_pre_orig_header in the header before the original header' do
+    files = fake( :includes_h_pre_orig_header => ['extra_h.h'] )
+
+    expect( position( files[:h], '#include "extra_h.h"' ) ).to be < position( files[:h], '#include "bar.h"' )
+  end
+
+  it 'includes :includes_h_post_orig_header in the header after the original header' do
+    files = fake( :includes_h_post_orig_header => ['extra_h.h'] )
+
+    expect( position( files[:h], '#include "extra_h.h"' ) ).to be > position( files[:h], '#include "bar.h"' )
+  end
+
+  it 'merges :includes with :includes_h_pre_orig_header, :includes first, each once' do
+    files = fake( :includes => ['first.h', 'both.h'], :includes_h_pre_orig_header => ['both.h', 'second.h'] )
+
+    expect( extra_includes( files[:h] ) ).to eq( ['#include "first.h"', '#include "both.h"', '#include "second.h"'] )
+  end
+
+  it 'keeps an angle-bracket include as written and quotes a bare name' do
+    files = fake( :includes_c_pre_header => ['<stdint.h>', 'extra_c.h'] )
+
+    expect( extra_includes( files[:c] ) ).to eq( ['#include <stdint.h>', '#include "extra_c.h"'] )
+  end
+
+  it 'includes a Unity helper in the source after the fake header, by its path from the mock root' do
+    helper = File.join( @root, 'support', 'helper.h' )
+    FileUtils.mkdir_p( File.dirname( helper ) )
+    File.write( helper, "\n" )
+
+    files = fake( :unity_helper_path => [helper] )
+
+    expect( position( files[:c], '#include "../support/helper.h"' ) ).to be > position( files[:c], '#include "mock_bar.h"' )
+  end
+
+  # CMock's :verbosity levels: 0 errors only, 1 warnings, 2 normal, 3 verbose
+  context 'at CMock\'s verbosity levels' do
+
+    it 'prints nothing for errors only or warnings' do
+      expect { fake( :verbosity => 0 ) }.not_to output.to_stdout
+      expect { fake( :verbosity => 1 ) }.not_to output.to_stdout
+    end
+
+    it 'announces each fake at normal verbosity, as CMock announces each mock' do
+      expect { fake( :verbosity => 2 ) }.to output( "Creating fake functions for bar...\n" ).to_stdout
+    end
+
+    it 'also names the files written at verbose' do
+      path = File.join( @root, 'mocks', 'mock_bar' )
+
+      expect { fake( :verbosity => 3 ) }.to output(
+        "Creating fake functions for bar...\n" \
+        "Creating fake functions: #{path}.h and #{path}.c\n"
+      ).to_stdout
+    end
+
+  end
+
+end

data/plugins/gcov/config/defaults_gcov.rb

@@ -41,7 +41,7 @@ DEFAULT_GCOV_LINKER_TOOL = {
   }
 
 DEFAULT_GCOV_FIXTURE_TOOL = {
-  :executable => '${1}'.freeze,
+  :executable => '"${1}"'.freeze, # Test executable, quoted as a path
   :name => 'default_gcov_fixture'.freeze,
   :optional => false.freeze,
   :arguments => [].freeze

data/plugins/gcov/gcov.rake

@@ -38,11 +38,12 @@ namespace GCOV_SYM do
     @ceedling[:gcov].process_untested_sources( sources:COLLECTION_ALL_SOURCE )
   end
 
-  desc 'Run single test w/ coverage ([*] test or source file name, no path).'
+  desc 'Run single test w/ coverage ([*] test or source file name, with optional 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`"
+              "Use a real test or source file name in place of the wildcard, " \
+              "adding as much of its path as needed to identify one file among any same-named tests.\n" \
+              "Example: `ceedling #{GCOV_ROOT_NAME}:foo.c` or `ceedling #{GCOV_ROOT_NAME}:unit/foo.c`"
 
     @ceedling[:loginator].log( message, Verbosity::ERRORS )
   end
@@ -83,12 +84,8 @@ namespace GCOV_SYM do
   # 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}/, '')
-        EXTENSION_SOURCE.each { |ext| test = test.chomp( ext ) }
-
-        # 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 ))
+        # Any directory typed ahead of the name is kept. See TestTaskName.
+        test = TestTaskName.test_name( task_name, root: GCOV_TASK_ROOT )
 
         # Provide the filepath for the target test task back to the Rake task
         @ceedling[:file_finder].find_test_file_from_name( test )

data/plugins/gcov/lib/console_reportinator.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
 require 'gcov_reportinator'
 
 class ConsoleReportinator < GcovReportinator
@@ -173,22 +173,8 @@ class ConsoleReportinator < GcovReportinator
   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)
+    # The coverage data sits beside the object, wherever the test's build placed it
+    obj_dir = File.dirname( @file_path_utils.form_test_object_filepath( source, name: test, context: GCOV_SYM ) )
 
     # Run gcov to extract the coverage summary
     command = @tool_executor.build_command_line(
@@ -197,7 +183,7 @@ class ConsoleReportinator < GcovReportinator
       (opts[:gcov_mcdc] ? ['-g'] : []),
       # Argument replacement
       filename, # .c source file compiled with coverage
-      obj_dir # <build>/gcov/out/<test name>[/mirrored subdir] for coverage data files
+      obj_dir # <build>/gcov/out/<test name>[/source directory] for coverage data files
     )
 
     # Do not raise an exception if `gcov` terminates with a non-zero exit code, just note it and move on.

data/plugins/gcov/lib/gcov.rb

@@ -12,6 +12,7 @@ require 'gcov_constants'
 require 'gcov_types'
 require 'gcov_reportinator'
 require 'console_reportinator'
+require 'gcovr_thresholds'
 require 'gcovr_reportinator'
 require 'reportgenerator_reportinator'
 
@@ -141,7 +142,7 @@ class Gcov < Plugin
 
       # Full filepaths (not basenames)
       header = "Untested source files not in the coverage report (:untested_sources is :list):"
-      @loginator.log_list( untested_sources.sort, header, Verbosity::COMPLAIN, LogLabels::WARNING )
+      @loginator.log_list( untested_sources.sort, header, Verbosity::COMPLAIN )
 
     when GCOV_UNTESTED_SOURCES_COMPILE
       validate_mcdc_gcc_version!
@@ -163,7 +164,7 @@ class Gcov < Plugin
       untested_sources.each do |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 )
+        dependencies = @file_path_utils.form_test_dependencies_filepath( object, 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 )
@@ -196,6 +197,9 @@ class Gcov < Plugin
           next
         end
 
+        @file_wrapper.mkdir( File.dirname( object ) )
+        @file_wrapper.mkdir( File.dirname( dependencies ) )
+
         begin
           @generator.generate_object_file_c(
             tool:         TOOLS_GCOV_COMPILER,
@@ -382,6 +386,9 @@ class Gcov < Plugin
 
       begin
         reportinator.generate_reports( @configurator.project_config_hash )
+      rescue GcovrThresholdError => ex
+        # Each violated threshold is its own build failure
+        ex.violations.each { |violation| @ceedling[:plugin_manager].register_build_failure( GCOV_SYM, violation ) }
       rescue => ex
         # Register the exception as a build failure
         @ceedling[:plugin_manager].register_build_failure( GCOV_SYM, ex.message )

data/plugins/gcov/lib/gcovr_reportinator.rb

@@ -7,8 +7,10 @@
 
 require 'ceedling/exceptions'
 require 'ceedling/constants'
+require 'ceedling/filename_extension'
 require 'gcov_types'
 require 'gcov_reportinator'
+require 'gcovr_thresholds'
 
 class GcovrReportinator < GcovReportinator
 
@@ -507,9 +509,8 @@ class GcovrReportinator < GcovReportinator
     data = build_exclusion_data
     patterns = []
 
-    # A source extension can be configured as more than one string, so its escaped forms
-    # are joined into one alternation rather than assuming there's only ever one to match.
-    src_extension_alternation = data[:src_extension].to_a.map { |ext| Regexp.escape(ext) }.join('|')
+    # A source extension can be configured as more than one string, so any one of them matches
+    src_extension_alternation = FilenameExtension.new( data[:src_extension] ).pattern
     test_prefix = Regexp.escape(data[:test_prefix].to_s)
     build_root = Regexp.escape(strip_leading_dot_slash(data[:build_root].to_s))
 
@@ -576,23 +577,6 @@ class GcovrReportinator < GcovReportinator
   end
 
 
-  # Returns the error message text from gcovr stderr, or nil if none found.
-  # Matches lines beginning with "error" or "(ERROR)" and extracts the trailing message.
-  def extract_gcovr_error_message(shell_result)
-    return nil if shell_result.nil?
-
-    stderr = shell_result[:stderr]
-    return nil if stderr.nil? || stderr.empty?
-
-    stderr.each_line do |line|
-      match = line.match( /^\(?error\S*\s+(.+)/i )
-      return match[1].strip.capitalize if match
-    end
-
-    nil
-  end
-
-
   # Extract the last contiguous block of lines containing '%' from gcovr stdout.
   # gcovr --print-summary emits lines like "lines: 69.6% (80 out of 115)" — this
   # locates that block generically without depending on exact line labels.
@@ -620,33 +604,17 @@ class GcovrReportinator < GcovReportinator
   end
 
 
-  # Output to console a human-friendly message on certain coverage failure exit codes.
-  # Prefers the actual gcovr error text from stderr; falls back to descriptive strings.
-  # gcovr's composite exit code bit-ORs every violated :fail_under_* threshold together --
-  # every violated bit is collected and reported, not just whichever is checked first.
+  # Reports every :fail_under_* threshold a gcovr run violated, raising when boom is set and
+  # logging otherwise. Returns whether the exit code holds a problem no threshold explains.
   def gcovr_exec_exception?(opts, exitcode, boom, shell_result=nil)
-    violations = []
-
-    {
-      2  => [:fail_under_line,     'Line'],
-      4  => [:fail_under_branch,   'Branch'],
-      8  => [:fail_under_decision, 'Decision'],
-      16 => [:fail_under_function, 'Function'],
-    }.each do |bit, (option, label)|
-      next unless ((exitcode & bit) == bit) && !opts[option].nil?
-
-      fallback = "#{label} coverage is less than the configured minimum of #{opts[option]}%"
-      violations << "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
-      exitcode &= ~bit
-    end
+    violations, exitcode = GcovrThresholds.decode( opts: opts, exitcode: exitcode, stderr: shell_result&.dig( :stderr ) )
 
     if boom
-      raise CeedlingException.new( violations.join("\n") ) unless violations.empty?
+      raise GcovrThresholdError.new( violations ) unless violations.empty?
     else
       violations.each { |msg| @loginator.log( msg, Verbosity::COMPLAIN ) }
     end
 
-    # A non-zero exit code is a problem
     return (exitcode != 0)
   end
 

data/plugins/gcov/lib/gcovr_thresholds.rb

@@ -0,0 +1,74 @@
+# =========================================================================
+#   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'
+
+# Coverage thresholds a gcovr run violated, one message each
+class GcovrThresholdError < CeedlingException
+
+  attr_reader :violations
+
+  def initialize(violations)
+    @violations = violations
+    super( violations.join( "\n" ) )
+  end
+
+end
+
+# Decodes gcovr's exit status and stderr into the :fail_under_* thresholds a run violated.
+# Each violated threshold sets a bit of the exit status and writes a line of its own to
+# stderr. Bit 8 covers both condition and decision coverage, which from gcovr 8.7 may
+# each write a line.
+module GcovrThresholds
+
+  BITS = {
+    2  => { option: :fail_under_line,     label: 'Line',                  kinds: ['line'] },
+    4  => { option: :fail_under_branch,   label: 'Branch',                kinds: ['branch'] },
+    8  => { option: :fail_under_decision, label: 'Condition or decision', kinds: ['condition', 'decision'] },
+    16 => { option: :fail_under_function, label: 'Function',              kinds: ['function'] },
+  }.freeze
+
+  MESSAGE_PATTERN = /^\(?error\)?:?\s+(failed minimum (\w+) coverage.*?)\s*$/i
+
+  # Returns the violation messages, and the exit status bits no configured threshold explains
+  def self.decode(opts:, exitcode:, stderr:)
+    messages = messages_by_kind( stderr )
+    violations = []
+
+    BITS.each do |bit, threshold|
+      next unless (exitcode & bit) == bit && !opts[threshold[:option]].nil?
+
+      violations.concat( violations_for( threshold, opts, messages ) )
+      exitcode &= ~bit
+    end
+
+    return violations, exitcode
+  end
+
+  # gcovr's own messages, grouped by the coverage kind each names. Older gcovr writes them in
+  # lowercase, so the first letter is capitalized, and nothing else is touched.
+  def self.messages_by_kind(stderr)
+    messages = Hash.new { |hash, kind| hash[kind] = [] }
+
+    stderr.to_s.each_line do |line|
+      match = line.match( MESSAGE_PATTERN )
+      messages[match[2].downcase] << match[1].sub( /\A./ ) { |first| first.upcase } if match
+    end
+
+    return messages
+  end
+
+  def self.violations_for(threshold, opts, messages)
+    found = threshold[:kinds].flat_map { |kind| messages[kind] }
+    found = ["#{threshold[:label]} coverage is less than the configured minimum of #{opts[threshold[:option]]}%"] if found.empty?
+
+    return found.map { |message| "Gcovr ⏩️ #{message}" }
+  end
+
+  private_class_method :messages_by_kind, :violations_for
+
+end

data/plugins/gcov/lib/reportgenerator_reportinator.rb

@@ -8,7 +8,7 @@
 require 'benchmark'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 require 'gcov_reportinator'
 
 class ReportGeneratorReportinator < GcovReportinator

data/plugins/module_generator/lib/module_generator.rb

@@ -110,7 +110,7 @@ class ModuleGenerator < Plugin
 
     @ceedling[:loginator].log(
       'Module Generator :update_svn is deprecated and ignored. Add generated files to source control with your own tools.',
-      Verbosity::COMPLAIN, LogLabels::WARNING
+      Verbosity::COMPLAIN
     )
   end
 
@@ -119,7 +119,7 @@ class ModuleGenerator < Plugin
     project.same_named( files.map { |file| file[:path].to_s } ).each do |planned, existing|
       @ceedling[:loginator].log(
         "Module file `#{planned}` shares its name with #{existing.map { |path| "`#{path}`" }.join( ', ' )}.",
-        Verbosity::COMPLAIN, LogLabels::WARNING
+        Verbosity::COMPLAIN
       )
     end
   end
@@ -133,7 +133,7 @@ class ModuleGenerator < Plugin
       @ceedling[:loginator].log(
         "Generated test `#{path}` is wrapped in `##{options.test_guard} #{define}`, but its build does not " \
         "define #{define}. Add it under :defines ↳ :test, or the test compiles to nothing.",
-        Verbosity::COMPLAIN, LogLabels::WARNING
+        Verbosity::COMPLAIN
       )
     end
   end

data/plugins/report_tests_teamcity_stdout/lib/report_tests_teamcity_stdout.rb

@@ -39,18 +39,13 @@ class ReportTestsTeamcityStdout < Plugin
   def pre_test(test)
     return if !@output_enabled
 
-    # Generate a new Flow ID and store it in test hash
+    # Generate a new Flow ID and open the test's suite. A suite is named for its test,
+    # which tells same-named tests in different directories apart.
     @mutex.synchronize do
       @flowid_count += 1
-      @suites[test] = { :flowid => @flowid_count }
-    end
+      @suites[test] = { :flowid => @flowid_count, :name => escape( @ceedling[:file_path_utils].form_test_name( test ) ) }
 
-    # Generate first TeamCity service message
-    @mutex.synchronize do
-      teamcity_service_message(
-        "testSuiteStarted name='#{File.basename(test, '.*')}'",
-        @suites[test][:flowid]
-      )
+      teamcity_service_message( "testSuiteStarted name='#{@suites[test][:name]}'", @suites[test][:flowid] )
     end
   end
 
@@ -58,103 +53,81 @@ class ReportTestsTeamcityStdout < Plugin
   def post_test_fixture_execute(arg_hash)
     return if !@output_enabled
 
-    flowId = nil
-    test_key = arg_hash[:test_filepath]
-
-    # Get unique Flow ID
-    @mutex.synchronize do
-      flowId = @suites[test_key][:flowid]
-    end
+    flowId = @mutex.synchronize { @suites[arg_hash[:test_filepath]][:flowid] }
 
     # Gather test results for this test executable
     results = @ceedling[:plugin_reportinator].assemble_test_results( [arg_hash[:result_file]] )
-
-    # Apportion total run time of test executable equally to each test case within it.
-    duration_ms = results[:total_time] * 1000.0
-    avg_duration = (duration_ms / [1, results[:counts][:passed] + results[:counts][:failed]].max).round
+    duration = average_duration( results )
 
     context = arg_hash[:context]
 
-    # Handle test case successes within the test executable
-    results[:successes].each do |success|
-      filepath = File.join( success[:source][:dirname], File.basename( success[:source][:basename], '.*' ) )
+    report_successes( results[:successes], context, flowId, duration )
+    report_failures( results[:failures], context, flowId, duration )
+    report_ignores( results[:ignores], context, flowId )
+  end
 
-      # puts(success)
-      success[:collection].each do |test|
-        _test = test[:test]
-
-        # Create Java-like name per TeamCity convention `package_or_namespace.ClassName.TestName`
-        #  ==> `context.TestFilepath.TestCaseName`
-        teamcity_service_message(
-          "testStarted name='#{context}.#{filepath}.#{_test}'",
-          flowId
-        )
-
-        teamcity_service_message(
-          "testFinished name='#{context}.#{filepath}.#{_test}' duration='#{avg_duration}'",
-          flowId
-        )
-      end
+  # `Plugin` build step hook
+  def post_test(test)
+    return if !@output_enabled
+
+    @mutex.synchronize do
+      teamcity_service_message(
+        "testSuiteFinished name='#{@suites[test][:name]}'",
+        @suites[test][:flowid]
+      )
     end
+  end
 
-    # Handle test case failures within the test executable
-    results[:failures].each do |failure|
-      failure[:collection].each do |test|
-        filepath = File.join( failure[:source][:dirname], File.basename( failure[:source][:basename], '.*' ) )
+  ### Private
 
-        _test = test[:test]
-        _message = test[:message]
+  private
 
-        teamcity_service_message(
-          "testStarted name='#{context}.#{filepath}.#{_test}'",
-          flowId
-        )
+  # Total run time of a test executable, apportioned equally to each test case within it, in ms
+  def average_duration(results)
+    duration_ms = results[:total_time] * 1000.0
 
-        # Create Java-like name per TeamCity convention `package_or_namespace.ClassName.TestName`
-        #  ==> `context.TestFilepath.TestCaseName`
-        _message = 
-          "testFailed name='#{context}.#{filepath}.#{_test}' " + 
-          "message='#{escape(_message)}' " +
-          "details='File: #{failure[:source][:file]} Line: #{test[:line]}'"
+    return (duration_ms / [1, results[:counts][:passed] + results[:counts][:failed]].max).round
+  end
 
-        teamcity_service_message( _message, flowId )
+  def report_successes(successes, context, flowId, duration)
+    successes.each do |success|
+      success[:collection].each do |test|
+        name = test_name( context, success[:source], test[:test] )
 
-        teamcity_service_message(
-          "testFinished name='#{context}.#{filepath}.#{_test}' duration='#{avg_duration}'",
-          flowId
-        )
+        teamcity_service_message( "testStarted name='#{name}'", flowId )
+        teamcity_service_message( "testFinished name='#{name}' duration='#{duration}'", flowId )
       end
     end
+  end
 
-    # Handle ignored tests
-    results[:ignores].each do |ignored|
-      ignored[:collection].each do |test|
-        filepath = File.join( ignored[:source][:dirname], File.basename( ignored[:source][:basename], '.*' ) )
-        _test = test[:test]
-
-        service_message = "testIgnored name='#{context}.#{filepath}.#{_test}'"
+  def report_failures(failures, context, flowId, duration)
+    failures.each do |failure|
+      failure[:collection].each do |test|
+        name = test_name( context, failure[:source], test[:test] )
+        details = escape( "File: #{failure[:source][:file]} Line: #{test[:line]}" )
 
-        teamcity_service_message( service_message, flowId )
+        teamcity_service_message( "testStarted name='#{name}'", flowId )
+        teamcity_service_message( "testFailed name='#{name}' message='#{escape( test[:message] )}' details='#{details}'", flowId )
+        teamcity_service_message( "testFinished name='#{name}' duration='#{duration}'", flowId )
       end
     end
-
   end
 
-  # `Plugin` build step hook
-  def post_test(test)
-    return if !@output_enabled
-
-    @mutex.synchronize do
-      teamcity_service_message(
-        "testSuiteFinished name='#{File.basename(test, '.*')}'",
-        @suites[test][:flowid]
-      )
+  def report_ignores(ignores, context, flowId)
+    ignores.each do |ignored|
+      ignored[:collection].each do |test|
+        teamcity_service_message( "testIgnored name='#{test_name( context, ignored[:source], test[:test] )}'", flowId )
+      end
     end
   end
 
-  ### Private
+  # A Java-like name per TeamCity convention `package_or_namespace.ClassName.TestName`
+  #  ==> `context.TestFilepath.TestCaseName`, escaped
+  def test_name(context, source, test)
+    filepath = File.join( source[:dirname], File.basename( source[:basename], '.*' ) )
 
-  private
+    return escape( "#{context}.#{filepath}.#{test}" )
+  end
 
   def escape(string)
     # https://www.jetbrains.com/help/teamcity/service-messages.html#Escaped+Values

data/plugins/sanitize/lib/sanitize_records.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
+require 'ceedling/build_log_writer'
 require 'sanitize_constants'
 require 'sanitize_reports'
 
@@ -20,7 +21,7 @@ class SanitizeRecords
     @loginator    = loginator
     @reports      = reports
     @records      = []
-    @logged_tests = []
+    @log_writer   = BuildLogWriter.new( file_wrapper: file_wrapper )
     @written      = []
     @mutex        = Mutex.new
   end
@@ -101,11 +102,7 @@ class SanitizeRecords
 
   # A build's first report for a test replaces the last build's log, and later ones follow it
   def write_log(log, findings)
-    first = @mutex.synchronize { !@logged_tests.include?( log ) && @logged_tests << log }
-    text  = findings.map( &:text ).join( "\n" )
-
-    @file_wrapper.mkdir( File.dirname( log ) )
-    @file_wrapper.write( log, first ? text : "\n#{text}", first ? 'w' : 'a' )
+    @log_writer.write( log, findings.map( &:text ).join( "\n" ), separator: "\n" )
   end
 
   def pluralize(count, word)