ceedling 1.2.1 → 1.2.2

data/spec/units/plugins/dependencies_spec.rb

@@ -50,7 +50,7 @@ describe Dependencies do
       tool_validator: double( 'tool_validator' ).tap { |validator| allow(validator).to receive(:validate).and_return( true ) },
       loginator: double( 'loginator', lazy: nil ).tap { |log| allow(log).to receive(:log) { |message, *| logged << message } },
       file_path_collection_utils: double( 'file_path_collection_utils', collect_paths: [] ),
-      file_path_utils: double( 'file_path_utils', form_release_build_list_filepath: 'list', form_test_build_map_filepath: 'map' ) }
+      file_path_utils: double( 'file_path_utils', form_test_build_map_filepath: 'map' ).tap { |utils| allow(utils).to receive(:form_release_build_list_filepath) { |path| path.ext( '.lst' ) } } }
   end
 
   def dependency(name = 'dep', **overrides)
@@ -245,10 +245,15 @@ describe Dependencies do
   end
 
   describe 'libraries' do
-    it 'names every library and its directory for linking, leaving executables out' do
-      plugin = plugin_for( dependency( artifacts: { static_libraries: ['libw.a'], dynamic_libraries: ['sub/libv.so'], executables: ['bin/tool'] } ) )
-
-      expect(plugin.link_libraries).to eq( names: ['w', 'v'], paths: ['deps/dep/build', 'deps/dep/build/sub'] )
+    # GH #1368: a link depends on each library's exact file, which a name can't always reach
+    it 'names every library, its directory, and its file for linking, leaving executables out' do
+      plugin = plugin_for( dependency( artifacts: { static_libraries: ['libw.a'], dynamic_libraries: ['sub/libv.so.1'], executables: ['bin/tool'] } ) )
+
+      expect(plugin.link_libraries).to eq(
+        names: ['w', 'v.so'],
+        paths: ['deps/dep/build', 'deps/dep/build/sub'],
+        files: ['deps/dep/build/libw.a', 'deps/dep/build/sub/libv.so.1']
+      )
     end
   end
 
@@ -266,7 +271,7 @@ describe Dependencies do
       plugin_for( lib ).make_if_required( 'dep' )
 
       expect(generator).to have_received(:generate_object_file_c)
-        .with( hash_including( source: 'cc/src/b.c', object: 'cc/build/b.o', search_paths: ['cc/inc'], defines: ['FAST'] ) )
+        .with( hash_including( source: 'cc/src/b.c', object: 'cc/build/src/b.o', search_paths: ['cc/inc'], defines: ['FAST'] ) )
       expect(executed).not_to include( a_string_starting_with( 'cd ' ) )
     end
 
@@ -274,10 +279,31 @@ describe Dependencies do
       plugin_for( lib ).make_if_required( 'dep' )
 
       expect(generator).to have_received(:generate_executable_file)
-        .with( anything, anything, ['cc/build/a.o', 'cc/build/b.o'], [], 'cc/build/libcc.a', 'map', [], [] )
+        .with( anything, anything, ['cc/build/a.o', 'cc/build/src/b.o'], [], 'cc/build/libcc.a', 'map', [], [] )
       expect(file_wrapper).to have_received(:cp).with( 'cc/build/libcc.a', 'cc/out/libcc.a' )
     end
 
+    it 'places two same-named sources\' objects apart, by their paths below the source path' do
+      allow(file_wrapper).to receive(:directory_listing) do |glob|
+        { 'cc/**/*.c' => ['cc/a/x.c', 'cc/b/x.c'] }.fetch( glob, [] )
+      end
+
+      plugin_for( lib ).make_if_required( 'dep' )
+
+      expect(generator).to have_received(:generate_executable_file)
+        .with( anything, anything, ['cc/build/a/x.o', 'cc/build/b/x.o'], [], 'cc/build/libcc.a', 'map', [], [] )
+      expect(file_wrapper).to have_received(:mkdir).with( 'cc/build/a' )
+      expect(file_wrapper).to have_received(:mkdir).with( 'cc/build/b' )
+    end
+
+    # The path handling audit around GH #1370: a list file named by its source alone lands in
+    # the working directory
+    it 'writes each object\'s list file beside it' do
+      plugin_for( lib ).make_if_required( 'dep' )
+
+      expect(generator).to have_received(:generate_object_file_c).with( hash_including( object: 'cc/build/src/b.o', list: 'cc/build/src/b.lst' ) )
+    end
+
     it 'checks its compiler and archiver before building' do
       plugin_for( lib ).make_if_required( 'dep' )
 

data/spec/units/plugins/dependency_spec_spec.rb

@@ -132,6 +132,23 @@ describe DependencySpec do
       expect(spec.include_directories( ->( glob ) { ["#{glob}/a", "#{glob}/b"] } )).to eq( ['out/inc/**/a', 'out/inc/**/b'] )
     end
 
+    # The path handling audit around GH #1370: an absolute artifact names itself
+    it 'keeps an absolute artifact or include path as written' do
+      lib = File.expand_path( '/opt/sdk/lib/libsdk.a' )
+      inc = File.expand_path( '/opt/sdk/inc' )
+      spec = spec_for( paths: { artifact: 'out' }, artifacts: { static_libraries: [lib], includes: [inc] } )
+
+      expect(spec.static_libraries).to eq( [lib] )
+      expect(spec.include_directories( ->( _glob ) { raise 'no glob here' } )).to eq( [inc] )
+    end
+
+    it 'reads its configured paths as every configured path is read, `~` as the home directory' do
+      spec = spec_for( paths: { source: '~/deps/w\\src\\', artifact: '~/deps/w/out' } )
+
+      expect(spec.source_path).to eq( File.join( Dir.home, 'deps/w/src' ) )
+      expect(spec.static_libraries).to eq( [File.join( Dir.home, 'deps/w/out/libworker.a' )] )
+    end
+
     it 'treats missing artifacts as empty' do
       spec = DependencySpec.build_all( [{ name: 'tool', fetch: { method: :none } }] ).first
 

data/spec/units/plugins/gcov_spec.rb

@@ -10,7 +10,7 @@ require 'yaml'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
 require 'ceedling/plugins/plugin'
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
 require 'ceedling/filename_extension'
 
 PROJECT_BUILD_ROOT           = 'build'     unless defined?(PROJECT_BUILD_ROOT)
@@ -176,7 +176,7 @@ describe Gcov do
     let(:test_build_setup) { double('test_build_setup', context_defines: [], flags: []) }
     let(:dependinator)    { double('dependinator', register: nil, register_gcc_deps_file: nil, flush: nil, mark_fresh: nil) }
     let(:generator)       { double('generator', generate_object_file_c: nil) }
-    let(:file_wrapper)    { double('file_wrapper', exist?: false) }
+    let(:file_wrapper)    { double('file_wrapper', exist?: false, mkdir: nil) }
     let(:test_invoker)    { double('test_invoker') }
 
     def build_process_gcov(project_config, ivars = {})
@@ -215,7 +215,7 @@ describe Gcov do
 
       it 'logs the full, sorted filepath list and records @untested_sources without compiling' do
         gcov = build_process_gcov({ gcov_untested_sources: GCOV_UNTESTED_SOURCES_LIST })
-        expect(loginator).to receive(:log_list).with(['src/a.c', 'src/b.c'], kind_of(String), Verbosity::COMPLAIN, LogLabels::WARNING)
+        expect(loginator).to receive(:log_list).with(['src/a.c', 'src/b.c'], kind_of(String), Verbosity::COMPLAIN)
         expect(generator).to_not receive(:generate_object_file_c)
         gcov.process_untested_sources(sources: ['src/b.c', 'src/a.c'])
         expect(gcov.instance_variable_get(:@untested_sources)).to eq(['src/b.c', 'src/a.c'])
@@ -243,6 +243,16 @@ describe Gcov do
         gcov.process_untested_sources(sources: ['src/a.c'])
       end
 
+      # An untested source's object sits at its path below the output root, in a
+      # directory no test build made
+      it 'makes the object\'s and dependencies file\'s directories before compiling' do
+        allow(dependinator).to receive(:stale?).and_return(true)
+        gcov = build_process_gcov({ gcov_untested_sources: GCOV_UNTESTED_SOURCES_COMPILE, gcov_mcdc: false })
+        expect(file_wrapper).to receive(:mkdir).with('build/gcov/out/src').twice.ordered
+        expect(generator).to receive(:generate_object_file_c).ordered
+        gcov.process_untested_sources(sources: ['src/a.c'])
+      end
+
       it 'compiles a stale object and marks it fresh' do
         allow(dependinator).to receive(:stale?).and_return(true)
         gcov = build_process_gcov({ gcov_untested_sources: GCOV_UNTESTED_SOURCES_COMPILE, gcov_mcdc: false })
@@ -341,6 +351,21 @@ describe Gcov do
       expect(succeeding).to have_received(:generate_reports)
     end
 
+    # GH #1366: every violated coverage threshold is its own entry, so each gets its own bullet
+    it 'registers each coverage threshold violation as its own build failure' do
+      failing = double('failing_reportinator', artifacts_path: nil, name: 'Gcovr', summary: '')
+      allow(failing).to receive(:generate_reports).and_raise(GcovrThresholdError.new(['line low', 'condition low']))
+
+      plugin_manager = double('plugin_manager')
+      expect(plugin_manager).to receive(:register_build_failure).with(GCOV_SYM, 'line low').ordered
+      expect(plugin_manager).to receive(:register_build_failure).with(GCOV_SYM, 'condition low').ordered
+
+      gcov = build_gcov({}, reports_enabled: true, configurator: configurator, ceedling: { plugin_manager: plugin_manager })
+      allow(gcov).to receive(:build_reportinators).and_return([failing])
+
+      gcov.generate_coverage_reports
+    end
+
     it 'logs the reportinator summary only when non-empty' do
       r_with_summary = double('r1', artifacts_path: nil, generate_reports: nil, name: 'R1', summary: 'coverage: 80%')
       r_without       = double('r2', artifacts_path: nil, generate_reports: nil, name: 'R2', summary: '')

data/spec/units/plugins/gcovr_reportinator_spec.rb

@@ -336,25 +336,30 @@ describe GcovrReportinator do
   describe '#gcovr_exec_exception?' do
     let(:reportinator) { build_reportinator({}) }
 
-    it 'raises one exception listing every violated :fail_under_* threshold, not just the first' do
-      opts = { fail_under_line: 90, fail_under_branch: 80 }
-      # exit code 6 = bit 2 (line) | bit 4 (branch)
+    LINE_AND_CONDITION_STDERR = "(ERROR) Failed minimum line coverage (got 76.7%, minimum 100.0%)\n" +
+                                "(ERROR) Failed minimum condition coverage (got 92.9%, minimum 100.0%)\n"
+
+    # GH #1366: a run failing line and condition coverage reported the line message twice
+    it 'raises one error carrying every violated threshold, each with its own gcovr message' do
+      opts = { fail_under_line: 100, fail_under_decision: 100 }
+      # exit code 10 = bit 2 (line) | bit 8 (condition or decision)
       expect {
-        reportinator.send(:gcovr_exec_exception?, opts, 6, true, { stderr: '' })
-      }.to raise_error(CeedlingException) { |ex|
-        expect(ex.message).to match(/Line coverage/)
-        expect(ex.message).to match(/Branch coverage/)
+        reportinator.send(:gcovr_exec_exception?, opts, 10, true, { stderr: LINE_AND_CONDITION_STDERR })
+      }.to raise_error(GcovrThresholdError) { |ex|
+        expect(ex.violations).to eq( [
+          'Gcovr ⏩️ Failed minimum line coverage (got 76.7%, minimum 100.0%)',
+          'Gcovr ⏩️ Failed minimum condition coverage (got 92.9%, minimum 100.0%)'
+        ] )
       }
     end
 
-    it 'logs (not raises) every violation, clearing their bits, when boom is false' do
-      opts = { fail_under_line: 90, fail_under_branch: 80 }
-      expect(loginator).to receive(:log).with(/Line coverage/, Verbosity::COMPLAIN)
-      expect(loginator).to receive(:log).with(/Branch coverage/, Verbosity::COMPLAIN)
-      # exit code 6 (line bit 2 | branch bit 4) is fully explained by the two configured
-      # thresholds above -- both bits clear, leaving no unexplained problem.
+    it 'logs (not raises) every violation once, clearing their bits, when boom is false' do
+      opts = { fail_under_line: 100, fail_under_decision: 100 }
+      expect(loginator).to receive(:log).with(/Failed minimum line coverage/, Verbosity::COMPLAIN).once
+      expect(loginator).to receive(:log).with(/Failed minimum condition coverage/, Verbosity::COMPLAIN).once
+      # Both bits are explained by the two configured thresholds, leaving no unexplained problem
       expect(
-        reportinator.send(:gcovr_exec_exception?, opts, 6, false, { stderr: '' })
+        reportinator.send(:gcovr_exec_exception?, opts, 10, false, { stderr: LINE_AND_CONDITION_STDERR })
       ).to eq(false)
     end
 
@@ -698,39 +703,6 @@ describe GcovrReportinator do
     end
   end
 
-  describe '#extract_gcovr_error_message' do
-    let(:reportinator) { build_reportinator({}) }
-
-    it 'returns nil for a nil shell_result' do
-      expect( reportinator.send(:extract_gcovr_error_message, nil) ).to be_nil
-    end
-
-    it 'returns nil when stderr is empty' do
-      expect( reportinator.send(:extract_gcovr_error_message, { stderr: '' }) ).to be_nil
-    end
-
-    it 'captures, trims, and capitalizes an (ERROR)-prefixed line' do
-      result = reportinator.send(:extract_gcovr_error_message, { stderr: "(ERROR) something went wrong.\n" })
-      expect(result).to eq('Something went wrong.')
-    end
-
-    it 'matches case-insensitively' do
-      result = reportinator.send(:extract_gcovr_error_message, { stderr: "error: lowercase message\n" })
-      expect(result).to eq('Lowercase message')
-    end
-
-    it 'uses only the first matching line among several' do
-      stderr = "(ERROR) first problem\n(ERROR) second problem\n"
-      result = reportinator.send(:extract_gcovr_error_message, { stderr: stderr })
-      expect(result).to eq('First problem')
-    end
-
-    it 'returns nil when no error-prefixed line exists' do
-      result = reportinator.send(:extract_gcovr_error_message, { stderr: "just some noise\n" })
-      expect(result).to be_nil
-    end
-  end
-
   describe '#extract_gcovr_summary' do
     let(:reportinator) { build_reportinator({}) }
 

data/spec/units/plugins/gcovr_thresholds_spec.rb

@@ -0,0 +1,95 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/exceptions'
+
+$: << File.expand_path('../../../../plugins/gcov/lib', __FILE__)
+
+require 'gcovr_thresholds'
+
+# GH #1366: every violated threshold took stderr's first (ERROR) line, so two violations
+# reported the line-coverage message twice and lost the other
+describe GcovrThresholds do
+  # gcovr 8.8, :mcdc on, --fail-under-line 100 --fail-under-decision 100 (exit 10 = 2 | 8).
+  # From 8.7, --fail-under-decision also checks condition coverage, so bit 8 carries two lines.
+  STDERR_8_8 = <<~STDERR
+    (ERROR) Failed minimum line coverage (got 50.0%, minimum 100.0%)
+    (ERROR) Failed minimum condition coverage (got 50.0%, minimum 100.0%)
+    (ERROR) Failed minimum decision coverage (got 0.0%, minimum 100.0%)
+  STDERR
+
+  def decode(opts, exitcode, stderr)
+    GcovrThresholds.decode( opts: opts, exitcode: exitcode, stderr: stderr )
+  end
+
+  it 'reports each violated threshold with its own gcovr message, once' do
+    violations, unexplained = decode( {fail_under_line: 100, fail_under_decision: 100}, 10, STDERR_8_8 )
+
+    expect(violations).to eq( [
+      'Gcovr ⏩️ Failed minimum line coverage (got 50.0%, minimum 100.0%)',
+      'Gcovr ⏩️ Failed minimum condition coverage (got 50.0%, minimum 100.0%)',
+      'Gcovr ⏩️ Failed minimum decision coverage (got 0.0%, minimum 100.0%)'
+    ] )
+    expect(unexplained).to eq( 0 )
+  end
+
+  it 'reports a decision message alone, as gcovr before 8.7 writes it' do
+    stderr = "(ERROR) Failed minimum decision coverage (got 40.0%, minimum 90.0%)\n"
+
+    violations, _ = decode( {fail_under_decision: 90}, 8, stderr )
+
+    expect(violations).to eq( ['Gcovr ⏩️ Failed minimum decision coverage (got 40.0%, minimum 90.0%)'] )
+  end
+
+  it 'keeps gcovr\'s capitalization' do
+    stderr = "(ERROR) Failed minimum branch coverage (got 1.0%, minimum MC/DC 2.0%)\n"
+
+    violations, _ = decode( {fail_under_branch: 2}, 4, stderr )
+
+    expect(violations.first).to end_with( 'Failed minimum branch coverage (got 1.0%, minimum MC/DC 2.0%)' )
+  end
+
+  it 'capitalizes the message an older gcovr writes in lowercase' do
+    stderr = "(ERROR) failed minimum line coverage (got 50.0%, minimum 90.0%)\n"
+
+    violations, _ = decode( {fail_under_line: 90}, 2, stderr )
+
+    expect(violations).to eq( ['Gcovr ⏩️ Failed minimum line coverage (got 50.0%, minimum 90.0%)'] )
+  end
+
+  it 'falls back to a description of each violated threshold that gcovr gave no message for' do
+    violations, _ = decode( {fail_under_line: 90, fail_under_decision: 80, fail_under_function: 70}, 2 | 8 | 16, '' )
+
+    expect(violations).to eq( [
+      'Gcovr ⏩️ Line coverage is less than the configured minimum of 90%',
+      'Gcovr ⏩️ Condition or decision coverage is less than the configured minimum of 80%',
+      'Gcovr ⏩️ Function coverage is less than the configured minimum of 70%'
+    ] )
+  end
+
+  it 'leaves unexplained every bit without a configured threshold' do
+    violations, unexplained = decode( {fail_under_line: 90}, 2 | 4 | 64, '' )
+
+    expect(violations.length).to eq( 1 )
+    expect(unexplained).to eq( 4 | 64 )
+  end
+
+  it 'reports nothing for a zero exit code, and accepts a nil stderr' do
+    expect( decode( {fail_under_line: 90}, 0, nil ) ).to eq( [[], 0] )
+  end
+end
+
+describe GcovrThresholdError do
+  it 'carries each violation, and joins them as its message' do
+    error = GcovrThresholdError.new( ['one', 'two'] )
+
+    expect(error).to be_a( CeedlingException )
+    expect(error.violations).to eq( ['one', 'two'] )
+    expect(error.message).to eq( "one\ntwo" )
+  end
+end

data/spec/units/plugins/module_generator_spec.rb

@@ -105,7 +105,7 @@ describe ModuleGenerator do
     config[:module_generator_update_svn] = true
     allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
     allow(unity).to receive(:generate)
-    expect(loginator).to receive(:log).with( /:update_svn.*deprecated/, Verbosity::COMPLAIN, LogLabels::WARNING )
+    expect(loginator).to receive(:log).with( /:update_svn.*deprecated/, Verbosity::COMPLAIN )
 
     plugin.create( request( 'Lair' ) )
   end
@@ -127,7 +127,7 @@ describe ModuleGenerator do
     allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
     allow(unity).to receive(:files_to_operate_on).with( 'Lair' ).and_return( [{ path: Pathname.new( 'src/Lair.c' ) }, planned_test( 'test/test_Lair.c' )] )
     allow(unity).to receive(:generate)
-    expect(loginator).to receive(:log).with( /`test\/test_Lair.c`.*`#ifdef TEST`.*:defines/m, Verbosity::COMPLAIN, LogLabels::WARNING ).once
+    expect(loginator).to receive(:log).with( /`test\/test_Lair.c`.*`#ifdef TEST`.*:defines/m, Verbosity::COMPLAIN ).once
 
     plugin.create( request( 'Lair' ) )
   end
@@ -138,7 +138,7 @@ describe ModuleGenerator do
     allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
     allow(unity).to receive(:files_to_operate_on).and_return( [planned_test( 'test/test_Lair.c' )] )
     allow(unity).to receive(:generate)
-    expect(loginator).to receive(:log).with( /`#if TEST`/, Verbosity::COMPLAIN, LogLabels::WARNING )
+    expect(loginator).to receive(:log).with( /`#if TEST`/, Verbosity::COMPLAIN )
 
     plugin.create( request( 'Lair' ) )
   end
@@ -156,7 +156,7 @@ describe ModuleGenerator do
     config.merge!( collection_all_source: ['lib/Lair.c'], collection_all_headers: [], collection_all_tests: [] )
     allow(ModuleGeneratorUnity).to receive(:new).and_return( unity )
     allow(unity).to receive(:files_to_operate_on).with( 'Lair' ).and_return( [{ path: Pathname.new( 'src/Lair.c' ) }] )
-    expect(loginator).to receive(:log).with( /`src\/Lair.c`.*`lib\/Lair.c`/, Verbosity::COMPLAIN, LogLabels::WARNING )
+    expect(loginator).to receive(:log).with( /`src\/Lair.c`.*`lib\/Lair.c`/, Verbosity::COMPLAIN )
     expect(unity).to receive(:generate).with( 'Lair' )
 
     plugin.create( request( 'Lair' ) )
@@ -192,7 +192,7 @@ describe ModuleGenerator do
       resolved_defines['test/test_widget.c'] = []
       allow(file_wrapper).to receive(:exist?).with( 'test/test_widget.c' ).and_return( false )
       allow(file_wrapper).to receive(:write)
-      expect(loginator).to receive(:log).with( /`test\/test_widget.c`.*`#ifdef TEST`/m, Verbosity::COMPLAIN, LogLabels::WARNING )
+      expect(loginator).to receive(:log).with( /`test\/test_widget.c`.*`#ifdef TEST`/m, Verbosity::COMPLAIN )
 
       plugin.test( request( 'widget' ) )
     end

data/spec/units/plugins/report_build_warnings_log_spec.rb

@@ -53,7 +53,7 @@ describe ReportBuildWarningsLog do
   describe '#post_build' do
     it 'logs that no warnings were produced and never touches the filesystem when nothing was collected' do
       expect(@loginator).to receive(:log).with("Build produced no warnings.\n")
-      expect(@file_wrapper).not_to receive(:mkdir)
+      expect(@file_wrapper).not_to receive(:mkdir_for)
       expect(@file_wrapper).not_to receive(:write)
 
       @plugin.post_build(0)
@@ -91,7 +91,7 @@ describe ReportBuildWarningsLog do
         collection: WarningCollector.new.warnings( "foo.c:3:5: warning: unused variable 'x'\nbar.c:9:1: warning: missing return\n" )
       }
 
-      expect(@file_wrapper).to receive(:mkdir).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test'))
+      allow(@file_wrapper).to receive(:mkdir_for) { |path| path }
       expect(@file_wrapper).to receive(:write).with(
         File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'warnings.log'),
         "foo.c:3:5: warning: unused variable 'x'\nbar.c:9:1: warning: missing return\n"
@@ -138,7 +138,7 @@ describe ReportBuildWarningsLog do
 
     def written
       files = []
-      allow(@file_wrapper).to receive(:mkdir)
+      allow(@file_wrapper).to receive(:mkdir_for) { |path| path }
       allow(@file_wrapper).to receive(:write) { |path, _| files << path }
       return files
     end

data/spec/units/plugins/report_log_writer_plugin_spec.rb

@@ -37,12 +37,21 @@ describe ReportLogWriterPlugin do
 
   describe '#artifact_filepath' do
     it 'ensures the per-context artifact directory exists and returns the joined filepath' do
-      expect(@file_wrapper).to receive(:mkdir).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test'))
+      expect(@file_wrapper).to receive(:mkdir_for).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'warnings.log')) { |path| path }
 
       filepath = @plugin.send(:artifact_filepath, :test, 'warnings.log')
 
       expect(filepath).to eq(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'warnings.log'))
     end
+
+    # GH #1364: a nested test's log sits in its own subdirectory
+    it 'ensures the directory of a filename with subdirectories exists' do
+      expect(@file_wrapper).to receive(:mkdir_for).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'test/unit/test_foo.raw.log')) { |path| path }
+
+      filepath = @plugin.send(:artifact_filepath, :test, 'test/unit/test_foo.raw.log')
+
+      expect(filepath).to eq(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'test/unit/test_foo.raw.log'))
+    end
   end
 
   describe '#flush_log' do

data/spec/units/plugins/report_tests_raw_output_log_spec.rb

@@ -72,7 +72,7 @@ describe ReportTestsRawOutputLog do
   describe '#post_build' do
     it 'logs that no extra output was produced and never touches the filesystem when nothing was collected' do
       expect(@loginator).to receive(:log).with("Tests produced no extra console output.\n")
-      expect(@file_wrapper).not_to receive(:mkdir)
+      expect(@file_wrapper).not_to receive(:mkdir_for)
       expect(@file_wrapper).not_to receive(:write)
 
       @plugin.post_build(0)
@@ -86,7 +86,7 @@ describe ReportTestsRawOutputLog do
         'TestFoo' => ["Debug: entering state X\n", "Debug: leaving state X\n"]
       }
 
-      expect(@file_wrapper).to receive(:mkdir).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test'))
+      allow(@file_wrapper).to receive(:mkdir_for) { |path| path }
       expect(@file_wrapper).to receive(:write).with(
         File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'TestFoo.raw.log'),
         "Debug: entering state X\nDebug: leaving state X\n"
@@ -94,5 +94,16 @@ describe ReportTestsRawOutputLog do
 
       @plugin.post_build(0)
     end
+
+    # GH #1364: a nested test's log sits beneath its name
+    it "makes the directory a nested test's log goes in" do
+      @plugin.instance_variable_get(:@raw_output)[:test] = { 'test/unit/test_foo' => ["Debug\n"] }
+      filepath = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'test/unit/test_foo.raw.log')
+
+      expect(@file_wrapper).to receive(:mkdir_for).with(filepath) { |path| path }
+      expect(@file_wrapper).to receive(:write).with(filepath, "Debug\n")
+
+      @plugin.post_build(0)
+    end
   end
 end

data/spec/units/plugins/report_tests_teamcity_stdout_spec.rb

@@ -8,6 +8,7 @@
 require 'spec_helper'
 require 'stringio'
 require 'ceedling/plugins/plugin'
+require 'ceedling/filesystem/file_path_utils'
 
 $: << File.expand_path('../../../../plugins/report_tests_teamcity_stdout/lib', __FILE__)
 require 'report_tests_teamcity_stdout'
@@ -23,7 +24,10 @@ describe ReportTestsTeamcityStdout do
     @plugin.instance_variable_set(:@flowid_count, 0)
     @plugin.instance_variable_set(:@suites, {})
     @plugin.instance_variable_set(:@stream, @stream)
-    @plugin.instance_variable_set(:@ceedling, { plugin_reportinator: @plugin_reportinator })
+    @plugin.instance_variable_set(:@ceedling, {
+      plugin_reportinator: @plugin_reportinator,
+      file_path_utils:     FilePathUtils.new( configurator: nil, file_wrapper: nil )
+    })
   end
 
   describe '#escape' do
@@ -38,8 +42,23 @@ describe ReportTestsTeamcityStdout do
       @plugin.post_test('test/TestFoo.c')
 
       lines = @stream.string.lines
-      expect(lines[0]).to eq("##teamcity[testSuiteStarted name='TestFoo' flowId='1']\n")
-      expect(lines[1]).to eq("##teamcity[testSuiteFinished name='TestFoo' flowId='1']\n")
+      expect(lines[0]).to eq("##teamcity[testSuiteStarted name='test/TestFoo' flowId='1']\n")
+      expect(lines[1]).to eq("##teamcity[testSuiteFinished name='test/TestFoo' flowId='1']\n")
+    end
+
+    # GH #1364: same-named tests in different directories are different suites
+    it 'names each suite by its test, so same-named tests are told apart' do
+      @plugin.pre_test('test/a/test_x.c')
+      @plugin.pre_test('test/b/test_x.c')
+
+      expect(@stream.string).to include("testSuiteStarted name='test/a/test_x'", "testSuiteStarted name='test/b/test_x'")
+    end
+
+    it 'escapes a suite name, as every TeamCity value is' do
+      @plugin.pre_test("test/o'neil/test_x.c")
+      @plugin.post_test("test/o'neil/test_x.c")
+
+      expect(@stream.string.lines).to all( include("name='test/o|'neil/test_x'") )
     end
 
     it 'gives each successive test its own flow id' do
@@ -108,6 +127,61 @@ describe ReportTestsTeamcityStdout do
     end
   end
 
+  # GH #1369: a reserved character in a test's path, case name, or failure location
+  # closed the quoted value early, and TeamCity misread or dropped the message
+  describe '#post_test_fixture_execute escaping' do
+    RESERVED_DIR  = "test/o'neil|x"
+    RESERVED_CASE = 'test_value(1, [2])'
+    ESCAPED_NAME  = "test.test/o|'neil||x/TestFoo.test_value(1, |[2|])"
+
+    before(:each) do
+      @plugin.instance_variable_get(:@suites)['test/TestFoo.c'] = { flowid: 1 }
+    end
+
+    def run_with(results)
+      allow(@plugin_reportinator).to receive(:assemble_test_results).and_return(
+        { total_time: 1.0, counts: { passed: 1, failed: 1 }, successes: [], failures: [], ignores: [] }.merge( results )
+      )
+      @plugin.post_test_fixture_execute(context: :test, test_filepath: 'test/TestFoo.c', result_file: 'x')
+    end
+
+    def source
+      { dirname: RESERVED_DIR, basename: 'TestFoo.c', file: "#{RESERVED_DIR}/TestFoo.c" }
+    end
+
+    it 'escapes the names of testStarted and testFinished for a passing test' do
+      run_with( successes: [ { source: source, collection: [ { test: RESERVED_CASE } ] } ] )
+
+      expect(@stream.string).to include(
+        "##teamcity[testStarted name='#{ESCAPED_NAME}' flowId='1']\n",
+        "##teamcity[testFinished name='#{ESCAPED_NAME}' duration='500' flowId='1']\n"
+      )
+    end
+
+    it 'escapes the name and details of testFailed, and the names around it' do
+      run_with( failures: [ { source: source, collection: [ { test: RESERVED_CASE, line: 7, message: 'm' } ] } ] )
+
+      expect(@stream.string).to include(
+        "##teamcity[testStarted name='#{ESCAPED_NAME}' flowId='1']\n",
+        "##teamcity[testFailed name='#{ESCAPED_NAME}' message='m' details='File: test/o|'neil||x/TestFoo.c Line: 7' flowId='1']\n",
+        "##teamcity[testFinished name='#{ESCAPED_NAME}' duration='500' flowId='1']\n"
+      )
+    end
+
+    it 'escapes the name of testIgnored' do
+      run_with( ignores: [ { source: source, collection: [ { test: RESERVED_CASE } ] } ] )
+
+      expect(@stream.string).to eq( "##teamcity[testIgnored name='#{ESCAPED_NAME}' flowId='1']\n" )
+    end
+
+    it 'keeps each message on one physical line when a name holds a line break' do
+      run_with( ignores: [ { source: source, collection: [ { test: "test_a\r\ntest_b" } ] } ] )
+
+      expect(@stream.string.lines.length).to eq( 1 )
+      expect(@stream.string).to include( 'TestFoo.test_a|r|ntest_b' )
+    end
+  end
+
   # A TeamCity service message must stay on one physical line
   describe '#escape' do
     it 'escapes a real newline as |n, keeping the whole message on one physical output line' do

data/spec/units/plugins/reportgenerator_reportinator_spec.rb

@@ -9,7 +9,7 @@ require 'spec_helper'
 require 'ceedling/tool_executor'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 
 PROJECT_BUILD_ROOT           = 'build'     unless defined?(PROJECT_BUILD_ROOT)
 PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)

data/spec/units/plugins/sanitize_records_spec.rb

@@ -8,6 +8,8 @@
 require 'spec_helper'
 require 'ceedling/constants'
 
+# Ceedling runtime path constants sanitize_constants.rb needs at require time
+PROJECT_BUILD_ROOT           = 'build'           unless defined?(PROJECT_BUILD_ROOT)
 PROJECT_BUILD_ARTIFACTS_ROOT = 'build/artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
 
 $: << File.expand_path('../../../../plugins/sanitize/lib', __FILE__)
@@ -15,7 +17,7 @@ require 'sanitize_findings'
 require 'sanitize_records'
 
 describe SanitizeRecords do
-  let(:file_wrapper) { double('file_wrapper', mkdir: nil, write: nil) }
+  let(:file_wrapper) { double('file_wrapper', mkdir: nil, write: nil, mkdir_for: nil) }
   let(:loginator)    { double('loginator', log: nil) }
   let(:records)      { described_class.new( file_wrapper: file_wrapper, loginator: loginator, reports: [] ) }
   let(:log)          { described_class.log_filepath( :sanitize, 'test_a' ) }

data/spec/units/plugins/sanitize_spec.rb

@@ -37,7 +37,7 @@ describe Sanitize do
 
   let(:loginator)      { double('loginator', log: nil) }
   let(:dependinator)   { double('dependinator', register: nil) }
-  let(:file_wrapper)   { double('file_wrapper', write: nil, mkdir: nil) }
+  let(:file_wrapper)   { double('file_wrapper', write: nil, mkdir: nil, mkdir_for: nil) }
   let(:plugin_manager) { double('plugin_manager', register_build_failure: nil) }
   let(:tracker)        { double('rake_invocation_tracker', invoked?: true) }
   let(:tool_validator) { double('tool_validator', validate: nil) }