ceedling 1.1.10 → 1.2.1

data/spec/integration/tool_executor_spec.rb

@@ -0,0 +1,224 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Unlike spec/units/tool_executor_spec.rb, this spec wires the REAL ToolExecutor +
+# ToolExecutorHelper + SystemWrapper + SystemUtils + Loginator + Verbosinator +
+# RubyExpandinator graph (see tool_executor_integration_helper.rb) and genuinely shells
+# out through SystemWrapper#shell_capture3 (Open3.capture3). The one external dependency
+# is `ruby` itself -- the same interpreter running this test suite -- rather than gcc or
+# any POSIX shell builtin, so every scenario here is available on every CI platform
+# (Linux/Windows/macOS) without a toolchain probe.
+#
+# Real scripts are written to real files via with_source_tree and invoked by their real
+# path, rather than passed inline via `-e`, specifically to avoid needing to reason about
+# cross-platform (sh vs. cmd.exe) command-line quoting for script CONTENT -- only a bare
+# file path need ever survive shell parsing, and script file content is real Ruby source
+# written straight to disk, immune to any shell-quoting concern entirely.
+
+require 'spec_helper'
+require 'spec_integration_helper'
+require 'tool_executor_integration_helper'
+require 'ceedling/constants'
+require 'ceedling/system_wrapper'
+require 'ceedling/system_utils'
+
+describe 'ToolExecutor (integration)' do
+  let(:executor) { real_tool_executor }
+
+  it 'builds and executes a real command end-to-end, returning real stdout' do
+    with_source_tree({ 'probe.rb' => 'puts "hello-from-ceedling"' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'probe.rb')])
+
+      command = executor.build_command_line(tool, [])
+      result = executor.exec(command)
+
+      expect(result[:stdout]).to include('hello-from-ceedling')
+      expect(result[:exit_code]).to eq(0)
+    end
+  end
+
+  it 'substitutes a real ${1} positional arg into a real shelled-out command' do
+    with_source_tree({ 'echo_arg.rb' => 'puts ARGV[0]' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'echo_arg.rb'), '${1}'])
+
+      command = executor.build_command_line(tool, [], 'ceedling-arg-value')
+      result = executor.exec(command)
+
+      expect(result[:stdout]).to include('ceedling-arg-value')
+    end
+  end
+
+  it 'raises ShellException with the real exit code when the real process exits non-zero and boom is true' do
+    with_source_tree({ 'fail.rb' => 'exit 3' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'fail.rb')])
+      command = executor.build_command_line(tool, [])
+
+      expect { executor.exec(command) }.to raise_error(ShellException) { |e|
+        expect(e.shell_result[:exit_code]).to eq(3)
+      }
+    end
+  end
+
+  it 'does not raise when boom is false, even though the real process exits non-zero' do
+    with_source_tree({ 'fail.rb' => 'exit 3' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'fail.rb')])
+      command = executor.build_command_line(tool, [])
+      command[:options] = { :boom => false }
+
+      result = executor.exec(command)
+
+      # Pins SystemWrapper's own real contract: :exit_code only ever reflects the real
+      # process's actual exit status when boom:true was passed through to it -- with
+      # boom:false it stays 0 regardless of what really happened. A caller handling its
+      # own failure asks #failed? instead, which the next example pins.
+      expect(result[:exit_code]).to eq(0)
+    end
+  end
+
+  it 'reports a real non-zero exit as failed when boom is false' do
+    with_source_tree({ 'fail.rb' => 'exit 3', 'pass.rb' => 'exit 0' }) do |dir|
+      results = ['fail.rb', 'pass.rb'].map do |script|
+        command = executor.build_command_line(ruby_tool_config(arguments: [File.join(dir, script)]), [])
+        command[:options] = { :boom => false }
+        executor.exec(command)
+      end
+
+      expect(executor.failed?(results[0])).to be true
+      expect(executor.failed?(results[1])).to be false
+    end
+  end
+
+  it 'captures real stderr output separately from real stdout' do
+    with_source_tree({ 'split.rb' => '$stdout.puts "on-stdout"; $stderr.puts "on-stderr"' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'split.rb')])
+      command = executor.build_command_line(tool, [])
+
+      result = executor.exec(command)
+
+      expect(result[:stdout]).to include('on-stdout')
+      expect(result[:stdout]).to_not include('on-stderr')
+      expect(result[:stderr]).to include('on-stderr')
+      expect(result[:stderr]).to_not include('on-stdout')
+    end
+  end
+
+  it 'measures a real non-negative elapsed :time for the real shell-out' do
+    with_source_tree({ 'probe.rb' => 'puts "done"' }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'probe.rb')])
+      command = executor.build_command_line(tool, [])
+
+      result = executor.exec(command)
+
+      expect(result[:time]).to be_a(Numeric)
+      expect(result[:time]).to be >= 0
+    end
+  end
+
+  it 'reads a real fixture file, whose path is substituted as a ${n} argument, through a real shell-out' do
+    with_source_tree({
+      'read_file.rb' => 'print File.read(ARGV[0])',
+      'input.txt'    => 'ceedling-fixture-content',
+    }) do |dir|
+      tool = ruby_tool_config(arguments: [File.join(dir, 'read_file.rb'), '${1}'])
+
+      command = executor.build_command_line(tool, [], File.join(dir, 'input.txt'))
+      result = executor.exec(command)
+
+      expect(result[:stdout]).to eq('ceedling-fixture-content')
+    end
+  end
+
+  it 'builds and runs a real command line using the tools.md-documented hash-style array-substitution shortcut' do
+    with_source_tree({ 'echo_args.rb' => 'print ARGV.join(",")' }) do |dir|
+      # Mirrors tools.md's own :test_linker example ("-l$-lib:" with a YAML array of
+      # plain library names) -- each array item is a literal value, not a Ruby constant
+      # or expression, dropped into the substitution string as-is.
+      tool = {
+        name: 'ruby_probe',
+        executable: RbConfig.ruby,
+        arguments: [File.join(dir, 'echo_args.rb'), { '$-suffix' => ['foo', 'bar'] }],
+      }
+
+      command = executor.build_command_line(tool, [])
+      result = executor.exec(command)
+
+      expect(result[:stdout]).to eq('foo-suffix,bar-suffix')
+    end
+  end
+
+  # Platform-detection-is-the-thing-under-test: SystemWrapper.windows?/SystemUtils#tcsh_shell?
+  # are the exact predicates ToolExecutorHelper itself branches on, so asserting against them
+  # directly checks "does the real resulting command actually work on this real platform" --
+  # something a unit test stubbing those predicates can never confirm. Different from
+  # dependency_tracker_filename_handling_spec.rb's empirical-probe style, which exists
+  # specifically because filesystem case-sensitivity is *not* reliably implied by RUBY_PLATFORM;
+  # here the platform predicate genuinely *is* what's under test.
+
+  context 'osify_path_separators on the real platform' do
+    it 'converts forward slashes to backslashes in the real executable path used to build the command line', skip: (SystemWrapper.windows? ? false : 'Windows-only: osify_path_separators is a no-op elsewhere') do
+      forward_slash_executable = RbConfig.ruby.tr('\\', '/')
+      tool = { name: 'ruby_probe', executable: forward_slash_executable, arguments: [] }
+
+      command = executor.build_command_line(tool, [])
+
+      expect(command[:executable]).to_not include('/')
+
+      result = executor.exec(command)
+      expect(result[:exit_code]).to eq(0)
+    end
+
+    it 'leaves a forward-slash executable path unchanged on a real non-Windows platform', skip: (SystemWrapper.windows? ? 'non-Windows-only' : false) do
+      tool = ruby_tool_config
+
+      command = executor.build_command_line(tool, [])
+
+      expect(command[:executable]).to eq(RbConfig.ruby)
+    end
+  end
+
+  context ':auto stderr redirect on the real platform' do
+    def redirect_probe_tool(dir)
+      ruby_tool_config(arguments: [File.join(dir, 'stderr_only.rb')])
+    end
+
+    it 'appends 2>&1 and runs successfully on real Windows', skip: (SystemWrapper.windows? ? false : 'Windows-only') do
+      with_source_tree({ 'stderr_only.rb' => '$stderr.puts "err-text"' }) do |dir|
+        tool = redirect_probe_tool(dir)
+        command = executor.build_command_line(tool, [])
+        command[:options] = { :stderr_redirect => StdErrRedirect::AUTO }
+
+        result = executor.exec(command)
+
+        expect(result[:exit_code]).to eq(0)
+      end
+    end
+
+    it 'appends 2>&1 and runs successfully on a real non-Windows, non-tcsh shell', skip: (!SystemWrapper.windows? && !SystemUtils.new(system_wrapper: SystemWrapper.new).tcsh_shell? ? false : 'requires non-Windows, non-tcsh') do
+      with_source_tree({ 'stderr_only.rb' => '$stderr.puts "err-text"' }) do |dir|
+        tool = redirect_probe_tool(dir)
+        command = executor.build_command_line(tool, [])
+        command[:options] = { :stderr_redirect => StdErrRedirect::AUTO }
+
+        result = executor.exec(command)
+
+        expect(result[:exit_code]).to eq(0)
+      end
+    end
+
+    it 'appends |& and runs successfully when the real shell is tcsh', skip: (!SystemWrapper.windows? && SystemUtils.new(system_wrapper: SystemWrapper.new).tcsh_shell? ? false : 'tcsh not available') do
+      with_source_tree({ 'stderr_only.rb' => '$stderr.puts "err-text"' }) do |dir|
+        tool = redirect_probe_tool(dir)
+        command = executor.build_command_line(tool, [])
+        command[:options] = { :stderr_redirect => StdErrRedirect::AUTO }
+
+        result = executor.exec(command)
+
+        expect(result[:exit_code]).to eq(0)
+      end
+    end
+  end
+end

data/spec/integration/tool_validator_spec.rb

@@ -0,0 +1,133 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Integration coverage for ToolValidator against a real filesystem and a real PATH.
+#
+# Whether a candidate file exists, how a quoted path with spaces resolves, and what PATH
+# a process actually searches are facts a doubled file layer cannot prove. A real
+# FileWrapper and SystemWrapper run here against real temp directories, with PATH set
+# per example. The unit spec at spec/units/tool_validator_spec.rb owns every decision
+# observable through doubles alone.
+
+require 'spec_helper'
+require 'spec_integration_helper'
+require 'fileutils'
+require 'ceedling/tool_validator'
+require 'ceedling/file_wrapper'
+require 'ceedling/system_wrapper'
+require 'ceedling/ruby_expandinator'
+require 'ceedling/filename_extension'
+require 'ceedling/constants'
+require 'ceedling/exceptions'
+
+describe 'ToolValidator (integration)' do
+  before(:each) do
+    @loginator = double('loginator')
+    allow(@loginator).to receive(:log)
+    verbosinator = double('verbosinator')
+    allow(verbosinator).to receive(:should_output?).and_return(false)
+
+    @validator = ToolValidator.new(
+      {
+        :file_wrapper      => FileWrapper.new( { :loginator => @loginator, :verbosinator => verbosinator } ),
+        :loginator         => @loginator,
+        :system_wrapper    => SystemWrapper.new,
+        :ruby_expandinator => RubyExpandinator.new
+      }
+    )
+  end
+
+  let(:no_extension) { FilenameExtension.new('') }
+
+  def validate(executable, extension: no_extension)
+    @validator.validate( tool: { :name => 'probe', :executable => executable, :stderr_redirect => :none }, extension: extension )
+  end
+
+  # Prepends `dir` to PATH for the block, restoring the original afterward
+  def with_path(dir)
+    original = ENV['PATH']
+    ENV['PATH'] = [dir, original].join( File::PATH_SEPARATOR )
+    yield
+  ensure
+    ENV['PATH'] = original
+  end
+
+  describe 'a bare executable name' do
+    it 'is found in a directory on PATH' do
+      with_source_tree( { 'bin/probe_tool' => '' } ) do |dir|
+        with_path( File.join( dir, 'bin' ) ) do
+          expect( validate( 'probe_tool' ) ).to be(true)
+        end
+      end
+    end
+
+    it 'is reported missing when no directory on PATH holds it' do
+      with_source_tree( { 'bin/probe_tool' => '' } ) do |dir|
+        with_path( File.join( dir, 'bin' ) ) do
+          expect(@loginator).to receive(:log).with( /does not exist in system search paths/, Verbosity::ERRORS )
+          expect( validate( 'absent_probe_tool' ) ).to be(false)
+        end
+      end
+    end
+
+    it 'is found under a configured extension it was written without' do
+      with_source_tree( { 'bin/probe_tool.sh' => '' } ) do |dir|
+        with_path( File.join( dir, 'bin' ) ) do
+          expect( validate( 'probe_tool', extension: FilenameExtension.new(['.sh']) ) ).to be(true)
+        end
+      end
+    end
+  end
+
+  describe 'an explicit executable path' do
+    it 'passes when written as an absolute path to a real file' do
+      with_source_tree( { 'tools/cc' => '' } ) do |dir|
+        expect( validate( File.join( dir, 'tools', 'cc' ) ) ).to be(true)
+      end
+    end
+
+    it 'passes when written relative to the working directory' do
+      with_source_tree( { 'tools/cc' => '' } ) do |dir|
+        Dir.chdir( dir ) { expect( validate( 'tools/cc' ) ).to be(true) }
+      end
+    end
+
+    it 'is reported missing on disk when the file does not exist' do
+      with_source_tree( { 'tools/cc' => '' } ) do |dir|
+        expect(@loginator).to receive(:log).with( /does not exist on disk/, Verbosity::ERRORS )
+        expect( validate( File.join( dir, 'tools', 'absent' ) ) ).to be(false)
+      end
+    end
+
+    it 'resolves a quoted path containing spaces, followed by arguments' do
+      with_source_tree( { 'code cruncher/cc' => '' } ) do |dir|
+        expect( validate( %("#{File.join( dir, 'code cruncher', 'cc' )}" --fast) ) ).to be(true)
+      end
+    end
+
+    it 'is found under a configured extension it was written without' do
+      with_source_tree( { 'tools/probe_tool.sh' => '' } ) do |dir|
+        expect( validate( File.join( dir, 'tools', 'probe_tool' ), extension: FilenameExtension.new(['.sh']) ) ).to be(true)
+      end
+    end
+  end
+
+  # Backslash paths and an omitted .exe exist as real files only on a Windows host
+  describe 'a Windows executable path', skip: (SystemWrapper.windows? ? false : 'Windows-only: backslash paths and .exe resolution') do
+    it 'passes when written with backslashes' do
+      with_source_tree( { 'tools/cc.exe' => '' } ) do |dir|
+        expect( validate( File.join( dir, 'tools', 'cc.exe' ).tr( '/', '\\' ) ) ).to be(true)
+      end
+    end
+
+    it 'finds the .exe file when written without its extension' do
+      with_source_tree( { 'tools/cc.exe' => '' } ) do |dir|
+        expect( validate( File.join( dir, 'tools', 'cc' ) ) ).to be(true)
+      end
+    end
+  end
+end

data/spec/integration/vendor_copy_transient_io_retry_spec.rb

@@ -0,0 +1,178 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# ConfiguratorSetup#vendor_frameworks_and_support_files with a real FileWrapper on a real
+# filesystem. A build brings build/vendor up to date with the gem's frameworks. It writes only
+# a file that differs from its source, and replaces it whole by renaming a temporary copy over
+# it, so a concurrent build never reads a half-written header (GH #1361). A transient copy
+# fault, such as a path briefly the wrong type (GH #1292), is retried, and one that never
+# clears names the destination.
+#
+# Faults are injected at FileWrapper#replace_file, the one write of each file, so the retry
+# loop in FileWrapper#sync_tree is what runs.
+
+require 'spec_helper'
+require 'spec_integration_helper'
+require 'ceedling/config/configurator_setup'
+require 'ceedling/constants'
+
+describe 'Vendor copy into build/vendor (integration)' do
+  include IntegrationSpecHelpers
+
+  # A real FileWrapper whose #replace_file raises for files beneath `fault_dir` the first
+  # `raises_left` times. Named apart from other specs' faulting wrappers, since top-level
+  # classes share one RSpec process.
+  class ReplaceFaultingFileWrapper < FileWrapper
+    def initialize(fault_dir:, raises_left: 1, error: Errno::EISDIR, **kwargs)
+      super(**kwargs)
+      @fault_dir = fault_dir
+      @raises_left = raises_left
+      @error = error
+    end
+
+    def replace_file(source, destination)
+      if destination.start_with?( @fault_dir ) && @raises_left > 0
+        @raises_left -= 1
+        raise @error, "simulated transient type-mismatch on #{destination}"
+      end
+      super
+    end
+  end
+
+  def file_wrapper(**fault)
+    options = { loginator: IntegrationSpecHelpers::NULL, verbosinator: IntegrationSpecHelpers::NULL }
+    return fault.empty? ? FileWrapper.new( options ) : ReplaceFaultingFileWrapper.new( **fault, **options )
+  end
+
+  def build_configurator_setup(file_wrapper)
+    ConfiguratorSetup.new(
+      configurator_builder:   IntegrationSpecHelpers::NULL,
+      configurator_validator: IntegrationSpecHelpers::NULL,
+      loginator:              IntegrationSpecHelpers::NULL,
+      reportinator:           IntegrationSpecHelpers::NULL,
+      file_wrapper:           file_wrapper,
+      system_wrapper:         IntegrationSpecHelpers::NULL,
+      tool_executor:          IntegrationSpecHelpers::NULL
+    )
+  end
+
+  # A stand-in for the gem's vendor/unity/src, with a nested file to show subdirectories copy
+  def flattened_config(dir)
+    unity_src = File.join( dir, 'gem_vendor', 'unity', 'src' )
+    FileUtils.mkdir_p( File.join( unity_src, 'internal' ) )
+    File.write( File.join( unity_src, 'unity.c' ), "// stand-in for unity.c\n" )
+    File.write( File.join( unity_src, 'unity.h' ), "// stand-in for unity.h\n" )
+    File.write( File.join( unity_src, 'internal', 'unity_internals.h' ), "// stand-in\n" )
+
+    {
+      # UNITY_LIB_PATH ('unity/src') joins this vendor root
+      unity_vendor_path:               File.join( dir, 'gem_vendor' ),
+      project_build_vendor_unity_path: File.join( dir, 'build', 'vendor', 'unity', 'src' ),
+      project_use_mocks:               false,
+      project_use_exceptions:          false,
+      project_use_backtrace:           :none,
+      project_use_partials:            false,
+    }
+  end
+
+  def vendor(file_wrapper, dir, config)
+    build_configurator_setup( file_wrapper ).vendor_frameworks_and_support_files( dir, config, test_build: true, release_build: false )
+  end
+
+  def snapshot(dest)
+    return Dir.glob( File.join( dest, '**', '*' ) ).select { |path| File.file?( path ) }.to_h do |path|
+      stat = File.stat( path )
+      [path, [stat.ino, stat.mtime]]
+    end
+  end
+
+  def leftovers(dest)
+    return Dir.glob( File.join( dest, '**', '*' ), File::FNM_DOTMATCH ).select { |path| File.basename( path ).include?( '.tmp' ) }
+  end
+
+  it "copies every file, including those in subdirectories, into a fresh destination" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+
+      vendor( file_wrapper, dir, config )
+
+      expect( File.read( File.join( dest, 'unity.h' ) ) ).to eq( "// stand-in for unity.h\n" )
+      expect( File.exist?( File.join( dest, 'internal', 'unity_internals.h' ) ) ).to be(true)
+      expect( leftovers( dest ) ).to be_empty
+    end
+  end
+
+  it "rewrites nothing when the destination already matches" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+      vendor( file_wrapper, dir, config )
+      before = snapshot( dest )
+      sleep( 1.1 ) # Past the coarsest file modification time resolution
+
+      vendor( file_wrapper, dir, config )
+
+      expect( snapshot( dest ) ).to eq( before )
+    end
+  end
+
+  it "restores an edited file by replacing it whole, and leaves matching files alone" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+      vendor( file_wrapper, dir, config )
+      edited = File.join( dest, 'unity.h' )
+      File.write( edited, "// an errant edit\n" )
+      before = snapshot( dest )
+
+      vendor( file_wrapper, dir, config )
+
+      expect( File.read( edited ) ).to eq( "// stand-in for unity.h\n" )
+      expect( File.stat( edited ).ino ).not_to eq( before[edited].first ) unless SystemWrapper.windows?
+      untouched = File.join( dest, 'unity.c' )
+      expect( snapshot( dest )[untouched] ).to eq( before[untouched] )
+      expect( leftovers( dest ) ).to be_empty
+    end
+  end
+
+  it "restores a missing file" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+      vendor( file_wrapper, dir, config )
+      FileUtils.rm( File.join( dest, 'internal', 'unity_internals.h' ) )
+
+      vendor( file_wrapper, dir, config )
+
+      expect( File.exist?( File.join( dest, 'internal', 'unity_internals.h' ) ) ).to be(true)
+    end
+  end
+
+  it "recovers from a transient copy failure instead of crashing the build" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+
+      expect { vendor( file_wrapper( fault_dir: dest, raises_left: 1 ), dir, config ) }.not_to raise_error
+
+      expect( File.exist?( File.join( dest, 'unity.c' ) ) ).to be(true)
+      expect( leftovers( dest ) ).to be_empty
+    end
+  end
+
+  it "raises a clear, path-naming CeedlingException when the fault never clears" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+
+      expect {
+        vendor( file_wrapper( fault_dir: dest, raises_left: 999 ), dir, config )
+      }.to raise_error( CeedlingException, /#{Regexp.escape( dest )}/ )
+    end
+  end
+end

data/spec/manual/stress_test.rb

@@ -22,7 +22,7 @@ tasks = {
 tasks.each_pair do |k,v|
   Dir.chdir(v[:dir]) do
     iterations.times do |i|
-      puts "=============== RUNNING ITERATION #{i+1}:\n#{k.to_s}\n===============\n\n"
+      puts "=============== RUNNING ITERATION #{i+1}:\n#{k}\n===============\n\n"
       stdout, stderr, status = Open3.capture3(k)
       puts stdout,stderr,status
       raise "\n\nCrashed on #{k} Iteration #{i+1}" unless status.success?

data/spec/support/config_yaml_helper.rb

@@ -0,0 +1,17 @@
+# =========================================================================
+#   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/yaml_wrapper'
+
+# Parses project configuration written as YAML, as a project file states it. A spec
+# reads like the configuration it describes and receives the symbol-keyed hash Ceedling
+# processes. Parsing a string touches no filesystem, so unit specs use it too.
+module ConfigYamlHelper
+  def config_from_yaml(yaml)
+    return YamlWrapper.new( { file_wrapper: nil } ).load_string( yaml )
+  end
+end

data/spec/support/fixtures/sanitizer_reports/clang_asan_heap.txt

@@ -0,0 +1,45 @@
+=================================================================
+==34860==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000a0 at pc 0x00010978ce5d bp 0x7ff7b6775f80 sp 0x7ff7b6775f78
+WRITE of size 4 at 0x6020000000a0 thread T0
+    #0 0x10978ce5c in main heap.c:3
+    #1 0x7ff80b4ac344 in start+0x774 (dyld:x86_64+0xfffffffffff5c344)
+
+0x6020000000a0 is located 0 bytes after 16-byte region [0x602000000090,0x6020000000a0)
+allocated by thread T0 here:
+    #0 0x10a221e40 in wrap_malloc+0xa0 (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0xdde40)
+    #1 0x10978cd98 in main heap.c:3
+    #2 0x7ff80b4ac344 in start+0x774 (dyld:x86_64+0xfffffffffff5c344)
+
+SUMMARY: AddressSanitizer: heap-buffer-overflow heap.c:3 in main
+Shadow bytes around the buggy address:
+  0x601ffffffe00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x601ffffffe80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x601fffffff00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x601fffffff80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x602000000000: fa fa fd fd fa fa 00 00 fa fa 00 06 fa fa 00 00
+=>0x602000000080: fa fa 00 00[fa]fa fa fa fa fa fa fa fa fa fa fa
+  0x602000000100: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x602000000180: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x602000000200: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x602000000280: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x602000000300: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07 
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+==34860==ABORTING

data/spec/support/fixtures/sanitizer_reports/clang_ubsan_shift.txt

@@ -0,0 +1,5 @@
+ub.c:3:67: runtime error: left shift of 128 by 24 places cannot be represented in type 'int'
+    #0 0x108be9ba9 in main ub.c:3
+    #1 0x7ff80b4ac344 in start+0x774 (dyld:x86_64+0xfffffffffff5c344)
+
+SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior ub.c:3:67 in 

data/spec/support/fixtures/sanitizer_reports/gcc_heap.txt

@@ -0,0 +1,47 @@
+=================================================================
+==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x502000000020 at pc 0x55b290ecf267 bp 0x7fff4af6e260 sp 0x7fff4af6e258
+WRITE of size 4 at 0x502000000020 thread T0
+    #0 0x55b290ecf266 in main /x/heap.c:3
+    #1 0x7f608be90ca7 in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58
+    #2 0x7f608be90d64 in __libc_start_main_impl ../csu/libc-start.c:360
+    #3 0x55b290ecf100 in _start (/x/heap.out+0x1100) (BuildId: 154354efc4ea5fd1903408c137d93f338aba841f)
+
+0x502000000020 is located 0 bytes after 16-byte region [0x502000000010,0x502000000020)
+allocated by thread T0 here:
+    #0 0x7f608c762c57 in malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:69
+    #1 0x55b290ecf1da in main /x/heap.c:3
+    #2 0x7f608be90ca7 in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58
+
+SUMMARY: AddressSanitizer: heap-buffer-overflow /x/heap.c:3 in main
+Shadow bytes around the buggy address:
+  0x501ffffffd80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x501ffffffe00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x501ffffffe80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x501fffffff00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x501fffffff80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+=>0x502000000000: fa fa 00 00[fa]fa fa fa fa fa fa fa fa fa fa fa
+  0x502000000080: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x502000000100: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x502000000180: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x502000000200: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x502000000280: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07 
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+==13==ABORTING

data/spec/support/fixtures/sanitizer_reports/gcc_leak.txt

@@ -0,0 +1,10 @@
+
+=================================================================
+==19==ERROR: LeakSanitizer: detected memory leaks
+
+Direct leak of 32 byte(s) in 1 object(s) allocated from:
+    #0 0x7f2d14743c57 in malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:69
+    #1 0x55db1ae3219a in main /x/leak.c:4
+    #2 0x7f2d13e71ca7 in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58
+
+SUMMARY: AddressSanitizer: 32 byte(s) leaked in 1 allocation(s).