ceedling 1.2.0 → 1.2.2

data/spec/integration/launcher_handoff_spec.rb

@@ -0,0 +1,297 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# GH #1365: a launcher ran another installation's application inside its own process,
+# so the application ran on a mix of both installations' code. Each command must now
+# run whole in the installation it selects.
+#
+# The second installation is real: `new --local` vendors this repository into a
+# project, and the copy gains the assets and examples a vendored copy leaves out, so
+# it can also run `new` and `examples`. Two markers make it distinguishable from the
+# launcher:
+#  - Its lib/version.rb reports 9.9.9.
+#  - Its bin/ceedling reports, on exit, how many of the launcher's own files its
+#    process loaded. A whole hand-off loads none.
+#
+# Every command here stops short of compiling, so no toolchain is needed.
+
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+require 'open3'
+require 'rbconfig'
+require 'yaml'
+require 'ceedling/installation'
+
+describe 'Launcher hand-off' do
+  REPO_ROOT = File.expand_path( '../..', __dir__ )
+  LAUNCHER_VERSION = Installation.new( REPO_ROOT ).version
+
+  # Registered as the copy's launcher starts, so it reports on every exit, failures
+  # included. It prints to stderr, so `dumpconfig --stdout` output stays pure YAML.
+  MARKER = <<~RUBY
+    at_exit {
+      launcher_files = $LOADED_FEATURES.count { |f| f.start_with?( '%<lib>s' ) or f.start_with?( '%<bin>s' ) }
+      $stderr.puts( "LAUNCHER FILES LOADED: \#{launcher_files}" )
+    }
+  RUBY
+
+  def ceedling(*args, env: {}, dir: @project)
+    stdout, stderr, status = Open3.capture3(
+      {'CEEDLING_DECORATORS' => 'false'}.merge( env ),
+      RbConfig.ruby, File.join( REPO_ROOT, 'bin', 'ceedling' ), *args,
+      chdir: dir
+    )
+    return stdout, stderr, status
+  end
+
+  # The copy ran its own command, loading none of the launcher's files
+  def expect_copy_ran(stderr)
+    expect(stderr).to include( 'LAUNCHER FILES LOADED: 0' )
+  end
+
+  before(:all) do
+    @tmp = Dir.mktmpdir( 'handoff' )
+    _, stderr, status = ceedling( 'new', '--local', 'proj', dir: @tmp )
+    raise "Could not create a vendored project:\n#{stderr}" unless status.success?
+
+    @project = File.join( @tmp, 'proj' )
+    @copy = File.join( @project, 'vendor', 'ceedling' )
+
+    version_rb = File.join( @copy, 'lib', 'version.rb' )
+    File.write( version_rb, File.read( version_rb ).sub( /BASE = '[^']+'/, "BASE = '9.9.9'" ) )
+    marker = format( MARKER, lib: File.join( REPO_ROOT, 'lib', 'ceedling' ), bin: File.join( REPO_ROOT, 'bin' ) )
+    launcher = File.join( @copy, 'bin', 'ceedling' )
+    shebang, rest = File.read( launcher ).split( "\n", 2 )
+    File.write( launcher, [shebang, marker, rest].join( "\n" ) )
+
+    ['assets', 'examples'].each { |dir| FileUtils.cp_r( File.join( REPO_ROOT, dir ), @copy ) }
+
+    @copy_version = Installation.new( @copy ).version
+  end
+
+  after(:all) do
+    FileUtils.rm_rf( @tmp )
+  end
+
+  it 'gives the copy a distinct version' do
+    expect(@copy_version).to eq( '9.9.9.dev' )
+    expect(@copy_version).to_not eq( LAUNCHER_VERSION )
+  end
+
+  describe '`version`' do
+    it 'reports both installations for a project whose :which_ceedling selects the copy' do
+      stdout, _, status = ceedling( 'version' )
+
+      expect(status.exitstatus).to eq( 0 )
+      expect(stdout).to include( "Ceedling Launcher => #{LAUNCHER_VERSION}" )
+      expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+    end
+
+    it 'reports the copy that WHICH_CEEDLING selects, with no project' do
+      stdout, _, _ = ceedling( 'version', env: {'WHICH_CEEDLING' => @copy}, dir: @tmp )
+
+      expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+    end
+
+    it 'reports the copy that a project named with --project selects, from elsewhere' do
+      Dir.mktmpdir do |elsewhere|
+        # :which_ceedling resolves against the working directory, so name the copy absolutely
+        mixin = File.join( elsewhere, 'which.yml' )
+        File.write( mixin, {:project => {:which_ceedling => @copy}}.to_yaml )
+
+        stdout, _, _ = ceedling( 'version', '--project', File.join( @project, 'project.yml' ), '--mixin', mixin, dir: elsewhere )
+
+        expect(stdout).to include( "Ceedling App => #{@copy_version}" )
+      end
+    end
+
+    it 'never hands off' do
+      _, stderr, _ = ceedling( 'version' )
+
+      expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+    end
+  end
+
+  describe 'project commands' do
+    it '`check` runs in the copy, with notices from both sides naming both versions' do
+      stdout, stderr, status = ceedling( 'check' )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(stdout).to include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is handing off to Ceedling #{@copy_version} at #{File.realpath( @copy )}/" ).or(
+        include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is handing off to Ceedling #{@copy_version} at #{@copy}/" )
+      )
+      expect(stdout).to match( /Ceedling #{Regexp.escape( @copy_version )} at .+ is now running, launched from Ceedling #{Regexp.escape( LAUNCHER_VERSION )} at #{Regexp.escape( REPO_ROOT )}\// )
+    end
+
+    ['environment', 'help', '-T'].each do |command|
+      it "`#{command}` runs in the copy" do
+        stdout, stderr, status = ceedling( command )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect_copy_ran( stderr )
+      end
+    end
+
+    it '`help` shows the copy\'s version in its footer' do
+      stdout, _, _ = ceedling( 'help' )
+
+      expect(stdout).to include( "Ceedling Packet User Manual (v#{@copy_version})" )
+    end
+
+    it '`dumpconfig --stdout` runs in the copy and writes nothing but YAML to stdout' do
+      stdout, stderr, status = ceedling( 'dumpconfig', '--stdout' )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(YAML.safe_load( stdout, permitted_classes: [Symbol] )).to include( :project )
+    end
+
+    it '`dumpconfig --no-app` runs in the copy' do
+      _, stderr, status = ceedling( 'dumpconfig', '--no-app', File.join( @tmp, 'dump.yml' ) )
+
+      expect(status.exitstatus).to eq( 0 ), stderr
+      expect_copy_ran( stderr )
+    end
+
+    it 'exits with the copy\'s failing status' do
+      Dir.mktmpdir do |mixins|
+        bad = File.join( mixins, 'bad.yml' )
+        File.write( bad, {:plugins => {:enabled => ['no_such_plugin']}}.to_yaml )
+
+        _, stderr, status = ceedling( 'check', '--mixin', bad )
+
+        expect(status.exitstatus).to eq( 1 )
+        expect_copy_ran( stderr )
+      end
+    end
+  end
+
+  describe 'commands without a project' do
+    it '`new` runs in the copy WHICH_CEEDLING selects, which vendors itself' do
+      Dir.mktmpdir do |dir|
+        _, stderr, status = ceedling( 'new', '--local', 'other', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect(status.exitstatus).to eq( 0 ), stderr
+        expect_copy_ran( stderr )
+        expect(Installation.new( File.join( dir, 'other', 'vendor', 'ceedling' ) ).version).to eq( @copy_version )
+        expect(File.read( File.join( dir, 'other', 'project.yml' ) )).to include( ":ceedling_version: #{@copy_version}" )
+      end
+    end
+
+    it '`examples` runs in the copy WHICH_CEEDLING selects' do
+      Dir.mktmpdir do |dir|
+        _, stderr, _ = ceedling( 'examples', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect_copy_ran( stderr )
+      end
+    end
+
+    it '`docs` exports the launcher\'s documentation, saying so, since the copy holds none' do
+      Dir.mktmpdir do |dir|
+        stdout, stderr, status = ceedling( 'docs', 'out', env: {'WHICH_CEEDLING' => @copy}, dir: dir )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+        expect(stdout).to include( "Ceedling #{@copy_version} at" )
+        expect(stdout).to include( "Exporting the documentation of Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ instead." )
+      end
+    end
+  end
+
+  describe '`upgrade`' do
+    it 'refuses to re-vendor a project from its own vendored copy' do
+      stdout, stderr, status = ceedling( 'upgrade', '.', env: {'WHICH_CEEDLING' => 'vendor/ceedling'} )
+
+      expect(status.exitstatus).to eq( 1 )
+      expect(stdout + stderr).to include( 'from itself' )
+      expect(File.directory?( @copy )).to be( true )
+    end
+  end
+
+  # A launcher before 1.2.2 loads the application into its own process. The application
+  # finishes the hand-off itself.
+  describe 'an application loaded into an older launcher\'s process' do
+    # Stands in for every 1.x launcher before 1.2.2: it builds its bin/ objects before
+    # Thor consumes ARGV, hands them over in CEEDLING_HANDOFF_OBJECTS, and requires the
+    # application's rakefile. Docker runs the real 1.0.0 through 1.2.1 launchers.
+    OLD_LAUNCHER = <<~RUBY
+      repo, app = ARGV.shift( 2 )
+      $LOAD_PATH.unshift( File.join( repo, 'bin' ) )
+      require 'app_cfg'
+      CEEDLING_APPCFG = CeedlingAppConfig.new
+      lib = CEEDLING_APPCFG[:ceedling_lib_path]
+      $LOAD_PATH.unshift( CEEDLING_APPCFG[:ceedling_lib_base_path], lib, File.join( lib, 'config' ), File.join( lib, 'filesystem' ),
+                          File.join( lib, 'rake_app' ), File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'diy', 'lib' ) )
+      require 'constructor'
+      require 'ceedling/constants'
+      require 'diy'
+      objects = DIY::Context.from_yaml( File.read( File.join( repo, 'bin', 'objects.yml' ) ) )
+      objects.build_everything
+      CEEDLING_HANDOFF_OBJECTS = [:rake_task_registry, :reportinator, :loginator, :file_wrapper, :yaml_wrapper,
+                                  :ruby_expandinator, :config_walkinator, :system_wrapper, :verbosinator].to_h { |n| [n, objects[n]] }
+      def boom_handler(_loginator, exception) = $stderr.puts( exception.message )
+      objects[:cli_helper].set_verbosity( Verbosity::NORMAL )
+      CEEDLING_APPCFG.set_paths( app )
+      require CEEDLING_APPCFG[:ceedling_rakefile_filepath]
+    RUBY
+
+    it 'restarts in its own process, with the original command line, saying so on both sides' do
+      script = File.join( @tmp, 'old_launcher.rb' )
+      File.write( script, OLD_LAUNCHER )
+
+      stdout, stderr, status = Open3.capture3(
+        {'CEEDLING_DECORATORS' => 'false'}, RbConfig.ruby, script, REPO_ROOT, @copy, 'check', chdir: @project
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect_copy_ran( stderr )
+      expect(stdout).to include( "Ceedling launcher #{LAUNCHER_VERSION} at #{REPO_ROOT}/ loaded Ceedling #{@copy_version}" )
+      expect(stdout).to include( "Restarting in Ceedling #{@copy_version}'s own process." )
+      expect(stdout).to include( 'Project configuration processed.' )
+    end
+
+    it 'warns and continues in that process when a hand-off already brought it there' do
+      stdout, stderr, status = ceedling(
+        'check', env: {'CEEDLING_HANDOFF_LAUNCHER' => '/elsewhere', 'CEEDLING_HANDOFF_TARGET' => REPO_ROOT}
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect(stderr).to_not include( 'LAUNCHER FILES LOADED' )
+      expect(stdout).to include( "Ceedling #{LAUNCHER_VERSION} at #{REPO_ROOT}/ is now running, launched from Ceedling at #{File.expand_path( '/elsewhere' )}/." )
+      expect(stdout).to include( "loaded Ceedling #{@copy_version}" )
+      expect(stdout).to include( "Continuing in the launcher's process" )
+    end
+  end
+
+  describe 'the vendored copy' do
+    it 'runs on its own, holding the built-in mixins its launcher validates' do
+      stdout, stderr, status = Open3.capture3(
+        {'CEEDLING_DECORATORS' => 'false'}, RbConfig.ruby, File.join( @copy, 'bin', 'ceedling' ), 'check', chdir: @project
+      )
+
+      expect(status.exitstatus).to eq( 0 ), stdout + stderr
+      expect(File.directory?( File.join( @copy, Installation::BUILTIN_MIXINS_DIR ) )).to be( true )
+    end
+
+    # Windows has ceedling.cmd, whose %* passes the command tail intact
+    it 'takes arguments through its ./ceedling launch script exactly as typed', unless: Installation.windows? do
+      Dir.mktmpdir do |dir|
+        dump = File.join( dir, 'dump with spaces.yml' )
+
+        stdout, stderr, status = Open3.capture3(
+          {'CEEDLING_DECORATORS' => 'false'}, './ceedling', 'dumpconfig', '--no-app', '--mixin', "=:project:\n  :name: Two Words", dump,
+          chdir: @project
+        )
+
+        expect(status.exitstatus).to eq( 0 ), stdout + stderr
+        expect(YAML.safe_load_file( dump, permitted_classes: [Symbol] )[:project][:name]).to eq( 'Two Words' )
+      end
+    end
+  end
+end

data/spec/integration/mixin_loading_spec.rb

@@ -50,7 +50,7 @@ require 'spec_helper'
 require 'tmpdir'
 require 'fileutils'
 require 'ceedling/constants'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/yaml_wrapper'
 require 'ceedling/ruby_expandinator'
 require 'ceedling/reportinator'

data/spec/integration/module_generator_spec.rb

@@ -21,8 +21,8 @@ require 'yaml'  # a Ceedling build always has YAML loaded
 require 'ceedling/constants'
 require 'ceedling/exceptions'
 require 'ceedling/plugins/plugin'
-require 'ceedling/file_finder_helper'
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_finder_helper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/config/config_matchinator'
 require 'ceedling/defineinator'
 
@@ -249,7 +249,7 @@ describe 'Module Generator plugin (integration)' do
         File.write( 'src/old/a_file.c', '' )
         plugin = plugin_for( config )
         loginator = plugin.instance_variable_get( :@ceedling )[:loginator]
-        expect(loginator).to receive(:log).with( /`src\/a_file.c`.*`src\/old\/a_file.c`/, anything, anything )
+        expect(loginator).to receive(:log).with( /`src\/a_file.c`.*`src\/old\/a_file.c`/, Verbosity::COMPLAIN )
 
         capture_stdout { plugin.create( ModuleGeneratorRequest.new( name: 'a_file' ) ) }
 

data/spec/integration/nested_test_artifacts_spec.rb

@@ -0,0 +1,99 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Per-test logs placed by a test's name, written with real file I/O in a temporary project.
+# A test's name is its path from the project root, so its logs sit in subdirectories that
+# must exist before anything writes there (GH #1364). Same-named tests keep separate gdb
+# logs, each holding only its latest build's crash.
+
+require 'spec_helper'
+require 'tmpdir'
+require 'ceedling/constants'
+require 'ceedling/plugins/plugin'
+require 'ceedling/filesystem/file_wrapper'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/build_log_writer'
+
+$LOAD_PATH.unshift( File.expand_path( '../../plugins/report_tests_raw_output_log/lib', __dir__ ) )
+$LOAD_PATH.unshift( File.expand_path( '../../plugins/valgrind/lib', __dir__ ) )
+
+# Ceedling runtime path constants the plugins need at require time
+PROJECT_BUILD_ROOT           = 'build'              unless defined?(PROJECT_BUILD_ROOT)
+PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts'          unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
+PROJECT_TEST_RESULTS_PATH    = 'build/test/results' unless defined?(PROJECT_TEST_RESULTS_PATH)
+
+require 'report_tests_raw_output_log'
+require 'valgrind'
+
+describe 'Per-test logs of nested tests (integration)' do
+  let(:loginator)    { double( 'loginator', log: nil ) }
+  let(:file_wrapper) { FileWrapper.new( { loginator: loginator, verbosinator: double( 'verbosinator', should_output?: false ) } ) }
+
+  def in_project
+    Dir.mktmpdir( 'nested' ) do |root|
+      Dir.chdir( root ) do
+        stub_const( 'PROJECT_BUILD_ARTIFACTS_ROOT', 'build/artifacts' )
+        stub_const( 'VALGRIND_ARTIFACTS_PATH', 'build/artifacts/valgrind' )
+        yield
+      end
+    end
+  end
+
+  it 'writes the raw-output log of a test below its root' do
+    in_project do
+      objects = { file_wrapper: file_wrapper, loginator: loginator, reportinator: double( 'reportinator', generate_heading: '', generate_progress: '' ) }
+      plugin  = ReportTestsRawOutputLog.new( objects, 'report_tests_raw_output_log', '/plugins/report_tests_raw_output_log' )
+
+      plugin.post_test_fixture_execute( context: :test, test_name: 'test/unit/test_calc', shell_result: { output: "hello\n" } )
+      plugin.post_build( 0 )
+
+      expect( File.read( 'build/artifacts/test/test/unit/test_calc.raw.log' ) ).to include( 'hello' )
+    end
+  end
+
+  # Valgrind writes its own report at the --log-file path a build hands it
+  it "reads the Valgrind report of a test below its root" do
+    in_project do
+      stub_const( 'TOOLS_VALGRIND', { name: 'valgrind', executable: 'valgrind', arguments: [] } )
+      valgrind = Valgrind.allocate
+      {
+        configurator: double( 'configurator', project_config_hash: {} ), loginator: loginator, file_wrapper: file_wrapper,
+        dependinator: double( 'dependinator', register: nil ), mutex: Mutex.new, result_list: [], memory_errors: 0,
+        tests_processed: 0, reports_read: 0, explained: []
+      }.each { |name, value| valgrind.instance_variable_set( "@#{name}", value ) }
+
+      arg_hash = { context: VALGRIND_SYM, test_name: 'test/unit/test_calc', target: 'build/valgrind/out/test/unit/test_calc/test_calc.out', tool: {} }
+      valgrind.pre_test_fixture_register( arg_hash )
+
+      report = arg_hash[:tool][:arguments].find { |argument| argument.start_with?( '--log-file=' ) }[/"(.+)"/, 1]
+      File.write( report, "==1== ERROR SUMMARY: 2 errors from 2 contexts\n" )
+
+      valgrind.post_test_fixture_execute( context: VALGRIND_SYM, test_name: 'test/unit/test_calc', result_file: 'test_calc.pass' )
+
+      expect( report ).to eq( 'build/artifacts/valgrind/test/unit/test_calc.log' )
+      expect( valgrind.instance_variable_get( :@reports_read ) ).to eq( 1 )
+      expect( valgrind.instance_variable_get( :@memory_errors ) ).to eq( 2 )
+    end
+  end
+
+  it 'keeps the gdb logs of same-named tests apart, each holding only the latest build' do
+    in_project do
+      paths = FilePathUtils.new( configurator: double( 'configurator', project_log_path: 'build/logs' ), file_wrapper: file_wrapper )
+      logs  = ['test/a/test_crash', 'test/b/test_crash'].map { |name| paths.form_test_gdb_log( name, context: :test, name: 'test_boom' ) }
+
+      2.times do |build|
+        writer = BuildLogWriter.new( file_wrapper: file_wrapper )
+        logs.each { |log| writer.write( log, "=== test_boom ===\nbuild #{build} #{log}\n" ) }
+      end
+
+      expect( logs.uniq.size ).to eq( 2 )
+      logs.each do |log|
+        expect( File.read( log ) ).to eq( "=== test_boom ===\nbuild 1 #{log}\n" )
+      end
+    end
+  end
+end

data/spec/integration/partials_module_resolution_spec.rb

@@ -20,11 +20,11 @@
 # sharing a basename in different directories.
 
 require 'spec_helper'
-require 'ceedling/file_finder'
-require 'ceedling/file_finder_helper'
+require 'ceedling/filesystem/file_finder'
+require 'ceedling/filesystem/file_finder_helper'
 require 'ceedling/filename_extension'
-require 'ceedling/path_matcher'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/path_matcher'
+require 'ceedling/filesystem/file_path_utils'
 require 'ceedling/constants'
 
 describe 'Partial module resolution (integration)' do
@@ -50,6 +50,7 @@ describe 'Partial module resolution (integration)' do
     allow(@configurator).to receive(:extension_source).and_return( FilenameExtension.new('.c') )
     allow(@configurator).to receive(:collection_all_headers).and_return( RESOLUTION_HEADERS )
     allow(@configurator).to receive(:collection_all_source).and_return( RESOLUTION_SOURCES )
+    allow(@configurator).to receive(:collection_all_tests).and_return( [] )
 
     @finder = FileFinder.new({
       :configurator      => @configurator,
@@ -134,6 +135,8 @@ describe 'Partial module resolution (integration)' do
     before(:each) do
       allow(@configurator).to receive(:project_build_root).and_return('build')
       allow(@configurator).to receive(:paths_include).and_return( ['include/**'] )
+      allow(@configurator).to receive(:collection_mirror_roots_include).and_return( ['include'] )
+      allow(@configurator).to receive(:collection_mirror_roots_headers).and_return( ['include'] )
       allow(@configurator).to receive(:paths_source).and_return( ['src/**'] )
       allow(@configurator).to receive(:paths_support).and_return( [] )
       allow(@configurator).to receive(:release_build_use_assembly).and_return( false )

data/spec/integration/path_intake_scenarios_spec.rb

@@ -0,0 +1,101 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# How configuration takes in the paths a project file names, before any build: where each
+# lands, and which a build can't use safely. Each example names the gap it probes (the path
+# handling audit around GH #1370). Where the right behavior is a policy still to be chosen,
+# the example states the one it assumes.
+
+require 'spec_helper'
+require 'configurator_integration_helper'
+
+describe 'Path intake (integration)' do
+  include ConfiguratorIntegrationHelpers
+
+  def yaml(project: {}, paths: {}, extra: '')
+    project_lines = { build_root: 'build' }.merge( project ).map { |key, value| "  :#{key}: #{value.inspect}" }.join( "\n" )
+    path_lines = { test: ['test/**'], source: ['src/**'], include: ['src/**'] }.merge( paths ).map { |key, value| "  :#{key}: #{value.inspect}" }.join( "\n" )
+    return ":project:\n#{project_lines}\n  :use_test_preprocessor: :none\n:paths:\n#{path_lines}\n#{extra}"
+  end
+
+  # Clobber empties the build root's test and release trees, so a build root holding the
+  # whole project is refused. An empty build root is left to the unit specs: it names the
+  # filesystem root, where a configuration that got past it would create directories.
+  { '.' => 'the project directory', '..' => 'a directory above the project' }.each do |root, what|
+    it "G16: refuses a build root that is #{what}" do
+      in_temp_project( minimal_project_files ) do
+        expect { configure( yaml( project: { build_root: root } ) ) }.to raise_error( CeedlingException )
+        expect(logged.join( "\n" )).to match( /build_root.*'#{Regexp.escape( root )}'/ )
+      end
+    end
+  end
+
+  it 'G16: accepts a build root beside the project\'s own directories' do
+    in_temp_project( minimal_project_files ) do
+      expect { configure( yaml( project: { build_root: 'out/build' } ) ) }.to_not raise_error
+    end
+  end
+
+  it 'G16: accepts a build root holding sources, warning of the entry' do
+    in_temp_project( minimal_project_files ) do
+      expect { configure( yaml( project: { build_root: 'src' } ) ) }.to_not raise_error
+      expect(logged.join( "\n" )).to match( %r{:paths ↳ :source => 'src/\*\*' lies in the build root 'src'} )
+    end
+  end
+
+  # A `-:` entry names what a build leaves out, and nothing there to leave out is no error.
+  # Below the build root, where nothing exists before a first build, it is not worth a word.
+  it 'G24: accepts a `-:` path below the build root that names nothing, silently' do
+    in_temp_project( minimal_project_files ) do
+      configure( yaml( paths: { include: ['src/**', '-:build/gen'] } ) )
+
+      expect(logged.join( "\n" )).to_not match( %r{build/gen} )
+    end
+  end
+
+  it 'G24: accepts a `-:` path elsewhere that names nothing, warning of it' do
+    in_temp_project( minimal_project_files ) do
+      configure( yaml( paths: { include: ['src/**', '-:src/gone'] } ) )
+
+      expect(logged.join( "\n" )).to match( %r{'-:src/gone' leaves out nothing} )
+    end
+  end
+
+  it "G18: includes a Unity helper written with backslashes in every mock by its own filename" do
+    files = minimal_project_files.merge( 'test/support/helper.h' => "\n" )
+    in_temp_project( files ) do
+      config = configure( yaml( extra: ":cmock:\n  :unity_helper_path: 'test\\support\\helper.h'\n" ) )[:configurator]
+
+      expect(config.cmock_includes).to include( 'helper.h' )
+    end
+  end
+
+  # Assumes an absolute release output names the release itself
+  it 'G19: places a release named by an absolute :output where it names' do
+    in_temp_project( minimal_project_files ) do |dir|
+      output = File.join( File.realpath( dir ), 'out', 'app.elf' )
+      config = configure( yaml( project: { release_build: true }, extra: ":release_build:\n  :output: #{output}\n" ) )[:configurator]
+
+      expect(config.project_release_build_target).to eq( output )
+    end
+  end
+
+  # Assumes `~` means the home directory, as it does in a shell
+  it 'G21: reads a `~` path as below the home directory' do
+    in_temp_project( minimal_project_files.merge( 'home/inc/extra.h' => "\n" ) ) do |dir|
+      home = ENV['HOME']
+      begin
+        ENV['HOME'] = File.join( File.realpath( dir ), 'home' )
+        config = configure( yaml( paths: { include: ['src/**', '~/inc'] } ) )[:configurator]
+
+        expect(config.collection_all_headers.map { |header| File.basename( header ) }).to include( 'extra.h' )
+      ensure
+        ENV['HOME'] = home
+      end
+    end
+  end
+end