ceedling 1.1.9 → 1.2.0

data/spec/units/path_matcher_spec.rb

@@ -0,0 +1,193 @@
+# =========================================================================
+#   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/path_matcher'
+require 'ceedling/exceptions'
+
+describe PathMatcher do
+
+  COLLECTION = [
+    'some/dir/a.c',
+    'another/place/b.c',
+    'here/src/c.cpp',
+    'here/inc/c.hpp',
+    'copy/SRC/c.cpp',
+    'copy/inc/c.hpp'
+  ].freeze
+
+  describe '.match' do
+    it 'finds a file by bare basename when it is unique in the collection' do
+      expect(described_class.match('a.c', COLLECTION)).to eq('some/dir/a.c')
+      expect(described_class.match('b.c', COLLECTION)).to eq('another/place/b.c')
+    end
+
+    it 'returns nil when no file in the collection has that basename' do
+      expect(described_class.match('nope.c', COLLECTION)).to be_nil
+    end
+
+    it 'returns nil when a query with a path prefix matches nothing' do
+      expect(described_class.match('missing/dir/a.c', COLLECTION)).to be_nil
+    end
+
+    it 'raises a CeedlingException naming every candidate when a bare basename is ambiguous' do
+      expect { described_class.match('c.cpp', COLLECTION) }.to raise_error(CeedlingException) do |error|
+        expect(error.message).to include('here/src/c.cpp')
+        expect(error.message).to include('copy/SRC/c.cpp')
+      end
+    end
+
+    it 'resolves an ambiguous basename when the query supplies enough trailing path to disambiguate' do
+      expect(described_class.match('src/c.cpp', COLLECTION)).to eq('here/src/c.cpp')
+      expect(described_class.match('SRC/c.cpp', COLLECTION)).to eq('copy/SRC/c.cpp')
+      expect(described_class.match('copy/inc/c.hpp', COLLECTION)).to eq('copy/inc/c.hpp')
+      expect(described_class.match('here/inc/c.hpp', COLLECTION)).to eq('here/inc/c.hpp')
+    end
+
+    it 'is still ambiguous when the supplied path narrows nothing (both candidates share that parent directory name)' do
+      expect { described_class.match('inc/c.hpp', COLLECTION) }.to raise_error(CeedlingException)
+    end
+
+    it 'matches path segments exactly, case-sensitively, not as a substring' do
+      # 'rc/c.cpp' is a substring of both 'src/c.cpp' entries' tails but is not a real
+      # path segment sequence of either -- it must not match anything.
+      expect(described_class.match('rc/c.cpp', COLLECTION)).to be_nil
+    end
+
+    it 'returns nil when the supplied path prefix matches no candidate at all' do
+      expect(described_class.match('other/c.cpp', COLLECTION)).to be_nil
+    end
+
+    it 'treats backslash-separated queries the same as forward-slash queries' do
+      expect(described_class.match('src\\c.cpp', COLLECTION)).to eq('here/src/c.cpp')
+    end
+
+    it 'matches an absolute path query only against its exact expanded file' do
+      absolute = File.expand_path('here/src/c.cpp')
+      expect(described_class.match(absolute, COLLECTION)).to eq('here/src/c.cpp')
+    end
+
+    it 'returns nil for an absolute path query with no corresponding file' do
+      absolute = File.expand_path('nowhere/c.cpp')
+      expect(described_class.match(absolute, COLLECTION)).to be_nil
+    end
+
+    it 'requires more path than just the basename when a query supplies only one segment among duplicates, even given an empty collection' do
+      expect(described_class.match('a.c', [])).to be_nil
+    end
+  end
+
+  describe '.resolve' do
+    it 'returns the single match and an empty passed-over list when a bare basename is unique' do
+      winner, others = described_class.resolve('a.c', COLLECTION)
+      expect(winner).to eq('some/dir/a.c')
+      expect(others).to eq([])
+    end
+
+    it 'returns nil and an empty passed-over list when nothing matches' do
+      winner, others = described_class.resolve('nope.c', COLLECTION)
+      expect(winner).to be_nil
+      expect(others).to eq([])
+    end
+
+    it 'never raises on an ambiguous bare basename -- picks the first candidate in collection order' do
+      winner, others = described_class.resolve('c.cpp', COLLECTION)
+      expect(winner).to eq('here/src/c.cpp')
+      expect(others).to eq(['copy/SRC/c.cpp'])
+    end
+
+    it 'still resolves via disambiguating trailing path exactly as .match does, with nothing passed over' do
+      winner, others = described_class.resolve('src/c.cpp', COLLECTION)
+      expect(winner).to eq('here/src/c.cpp')
+      expect(others).to eq([])
+    end
+
+    it 'picks the first of three or more ambiguous candidates, naming the rest as passed over' do
+      collection = ['b/x.h', 'a/x.h', 'c/x.h']
+      winner, others = described_class.resolve('x.h', collection)
+      expect(winner).to eq('b/x.h')
+      expect(others).to eq(['a/x.h', 'c/x.h'])
+    end
+
+    it 'resolves an empty collection to nil with nothing passed over' do
+      winner, others = described_class.resolve('a.c', [])
+      expect(winner).to be_nil
+      expect(others).to eq([])
+    end
+  end
+
+  describe '.resolve_relative' do
+    it 'returns a query with no .. segment completely unchanged, anchor or not' do
+      expect(described_class.resolve_relative('foo/bar.h')).to eq('foo/bar.h')
+      expect(described_class.resolve_relative('foo/bar.h', anchor: 'test/unit')).to eq('foo/bar.h')
+    end
+
+    it 'resolves a single leading .. against the anchor directory' do
+      expect(described_class.resolve_relative('../common/helper.h', anchor: 'test/unit')).to eq('test/common/helper.h')
+    end
+
+    it 'resolves multiple leading .. segments, one anchor segment popped per ..' do
+      expect(described_class.resolve_relative('../../common/helper.h', anchor: 'test/unit/adc')).to eq('test/common/helper.h')
+    end
+
+    it 'collapses an internal .. against an empty-string anchor, for an already self-contained path' do
+      # This is the shape GCC itself produces for a directory-relative quoted include --
+      # a complete, project-root-relative path that merely needs its own .. collapsed,
+      # not prefixed onto some other anchor.
+      expect(described_class.resolve_relative('test/unit/../common/helper.h', anchor: '')).to eq('test/common/helper.h')
+    end
+
+    it 'raises a CeedlingException naming the query when .. is present and no anchor is available' do
+      expect { described_class.resolve_relative('../common/helper.h') }.to raise_error(CeedlingException) do |error|
+        expect(error.message).to include('../common/helper.h')
+      end
+    end
+
+    # A project's paths may lie above its own root, such as `:paths` ↳ `:include: [../shared]`
+    # or a dependency beside the project, and GCC names such a header `../shared/shared.h`
+    it 'keeps the .. segments that climb above a relative anchor' do
+      expect(described_class.resolve_relative('../../common/helper.h', anchor: 'test')).to eq('../common/helper.h')
+      expect(described_class.resolve_relative('../shared/shared.h', anchor: '')).to eq('../shared/shared.h')
+      expect(described_class.resolve_relative('../../a/b.h', anchor: '')).to eq('../../a/b.h')
+    end
+
+    it 'collapses an internal .. within a path that lies above the anchor' do
+      expect(described_class.resolve_relative('../supervisor/build/../src/supervisor.h', anchor: '')).to eq('../supervisor/src/supervisor.h')
+    end
+
+    it 'raises a CeedlingException naming the query when .. climbs above an absolute anchor root' do
+      expect { described_class.resolve_relative('../../common/helper.h', anchor: '/test') }.to raise_error(CeedlingException) do |error|
+        expect(error.message).to include('../../common/helper.h')
+      end
+    end
+
+    it 'passes an absolute query through unchanged, even one containing .., deferring to expand_path-based matching elsewhere' do
+      expect(described_class.resolve_relative('/abs/unit/../common/helper.h')).to eq('/abs/unit/../common/helper.h')
+    end
+
+    it 'passes a Windows drive-letter query through unchanged, even one containing ..' do
+      expect(described_class.resolve_relative('C:\\unit\\..\\common\\helper.h')).to eq('C:\\unit\\..\\common\\helper.h')
+    end
+
+    it 'treats a backslash-separated .. query the same as a forward-slash one' do
+      expect(described_class.resolve_relative('..\\common\\helper.h', anchor: 'test/unit')).to eq('test/common/helper.h')
+    end
+
+    it 'preserves a leading / when the anchor itself is an absolute Unix path' do
+      # segments() rejects the empty string a leading "/" splits off -- naively
+      # rejoining with "/" then loses that leading slash entirely, silently turning
+      # an absolute anchor into a relative-looking result with the same text minus
+      # its leading "/". A caller anchoring against a real absolute file path (e.g.
+      # PreprocessinatorIncludesHandler#tag_literal_include, anchoring on
+      # File.dirname(filepath)) needs the result to still BE absolute.
+      expect(
+        described_class.resolve_relative('../common/helper.h', anchor: '/var/project/test')
+      ).to eq('/var/project/common/helper.h')
+    end
+  end
+
+end

data/spec/units/path_mirror_spec.rb

@@ -0,0 +1,103 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/path_mirror'
+
+describe PathMirror do
+
+  describe '.relative_subdir' do
+    it 'returns an empty string for a file directly inside a configured root' do
+      expect(described_class.relative_subdir('src/foo.c', ['src/**'])).to eq('')
+    end
+
+    it 'returns the directory structure below a configured root' do
+      expect(described_class.relative_subdir('src/drivers/foo.c', ['src/**'])).to eq('drivers')
+      expect(described_class.relative_subdir('src/drivers/sensors/foo.c', ['src/**'])).to eq('drivers/sensors')
+    end
+
+    it 'strips +:/-: aggregation decorators from configured roots before comparing' do
+      expect(described_class.relative_subdir('src/drivers/foo.c', ['+:src/**'])).to eq('drivers')
+      expect(described_class.relative_subdir('src/drivers/foo.c', ['-:src/**'])).to eq('drivers')
+    end
+
+    it 'picks the most specific (longest) matching root when configured roots are nested' do
+      roots = ['src/**', 'src/legacy/**']
+      expect(described_class.relative_subdir('src/legacy/foo.c', roots)).to eq('')
+      expect(described_class.relative_subdir('src/legacy/vendor/foo.c', roots)).to eq('vendor')
+      expect(described_class.relative_subdir('src/drivers/foo.c', roots)).to eq('drivers')
+    end
+
+    it 'returns an empty string when no configured root contains the file' do
+      expect(described_class.relative_subdir('build/vendor/unity/src/unity.c', ['src/**'])).to eq('')
+    end
+
+    it 'returns an empty string when given no roots at all' do
+      expect(described_class.relative_subdir('src/drivers/foo.c', [])).to eq('')
+    end
+
+    it 'treats a plain, non-globbed root the same as a globbed one' do
+      expect(described_class.relative_subdir('src/drivers/foo.c', ['src'])).to eq('drivers')
+    end
+  end
+
+  describe '.clean_roots and .relative_subdir_from_clean_roots' do
+    it 'produces the same result as .relative_subdir when roots are cleaned once upfront' do
+      clean = described_class.clean_roots(['+:src/**', '-:src/legacy/**'])
+      expect(described_class.relative_subdir_from_clean_roots('src/drivers/foo.c', clean)).to eq('drivers')
+      expect(described_class.relative_subdir_from_clean_roots('src/legacy/vendor/foo.c', clean)).to eq('vendor')
+    end
+
+    it 'drops decorated roots that clean to nothing' do
+      expect(described_class.clean_roots(['+:', '-:*.c', 'src'])).to eq(['src'])
+    end
+  end
+
+
+  # Distinct from `relative_subdir`, which answers '' both for a file sitting directly in a
+  # root and for one no root contains. A caller that must tell those apart -- one deciding
+  # whether to rewrite a query at all -- needs the difference.
+  describe '.relative_subdir_if_rooted' do
+    it 'returns the subdirectory below the matching root' do
+      expect( PathMirror.relative_subdir_if_rooted('include/drivers/uart/config.h', ['include/**']) )
+        .to eq('drivers/uart')
+    end
+
+    it 'returns an empty string for a file sitting directly in a root' do
+      expect( PathMirror.relative_subdir_if_rooted('include/config.h', ['include']) ).to eq('')
+    end
+
+    it 'returns nil when no root contains the file' do
+      expect( PathMirror.relative_subdir_if_rooted('src/config.c', ['include']) ).to be_nil
+    end
+
+    it 'prefers the longest matching root' do
+      expect( PathMirror.relative_subdir_if_rooted('include/drivers/uart/config.h', ['include', 'include/drivers']) )
+        .to eq('uart')
+    end
+
+    it 'returns nil for an empty root list' do
+      expect( PathMirror.relative_subdir_if_rooted('include/config.h', []) ).to be_nil
+    end
+  end
+
+  # One spelling of path-segment comparison, shared by every caller that matches trailing
+  # path segments rather than whole paths.
+  describe '.path_segments' do
+    it 'splits on either separator' do
+      expect( PathMirror.path_segments('drivers/uart\\config') ).to eq(['drivers', 'uart', 'config'])
+    end
+
+    it 'folds case so comparison is case-insensitive' do
+      expect( PathMirror.path_segments('Drivers/UART') ).to eq(['drivers', 'uart'])
+    end
+
+    it 'drops empty segments from doubled or trailing separators' do
+      expect( PathMirror.path_segments('drivers//uart/') ).to eq(['drivers', 'uart'])
+    end
+  end
+end

data/spec/units/plugin_manager_spec.rb

@@ -39,10 +39,87 @@ describe PluginManager do
       expect(@pm.plugins_failed?).to be(false)
     end
 
+    # A delta build reports a skipped test's results from the last build, without running it
+    it 'prints no raw output for a test reported from cached results' do
+      allow(@configurator).to receive(:plugins_display_raw_test_results).and_return(true)
+      allow(@loginator).to receive(:log)
+
+      arg_hash = { :context => TEST_SYM, :shell_result => nil, :results => { :counts => { :failed => 1 } } }
+      @pm.post_test_fixture_execute(arg_hash)
+
+      expect(@loginator).not_to have_received(:log)
+      expect(@pm.plugins_failed?).to be(true)
+    end
+
     it 'does not register a build failure when result counts are absent' do
       arg_hash = { :context => TEST_SYM, :shell_result => { :output => '' }, :results => {} }
       @pm.post_test_fixture_execute(arg_hash)
       expect(@pm.plugins_failed?).to be(false)
     end
   end
+
+  # These fire ahead of TestBuildExecutor's own dependency-tracker meta capture (see
+  # TestBuildExecutor's resolve_compile_tool/resolve_link_tool/resolve_fixture_tool) --
+  # distinct from and additional to the existing pre_compile_execute/pre_link_execute/
+  # pre_test_fixture_execute hooks, which only fire for a target actually rebuilt.
+  describe 'pre_test_compile_register / pre_test_link_register / pre_test_fixture_register' do
+    before(:each) do
+      allow(@loginator).to receive(:lazy)
+    end
+
+    def stub_plugin_implementing(method)
+      plugin = double('plugin', :name => 'fake')
+      allow(plugin).to receive(:respond_to?).and_return(false)
+      allow(plugin).to receive(:respond_to?).with(method).and_return(true)
+      @pm.instance_variable_set(:@plugin_objects, [plugin])
+      plugin
+    end
+
+    it 'dispatches pre_test_compile_register to a plugin implementing it, with the given arg_hash' do
+      plugin = stub_plugin_implementing(:pre_test_compile_register)
+      arg_hash = { tool: 'fake tool' }
+
+      expect(plugin).to receive(:pre_test_compile_register).with(arg_hash)
+      @pm.pre_test_compile_register(arg_hash)
+    end
+
+    it 'dispatches pre_test_link_register to a plugin implementing it, with the given arg_hash' do
+      plugin = stub_plugin_implementing(:pre_test_link_register)
+      arg_hash = { tool: 'fake tool' }
+
+      expect(plugin).to receive(:pre_test_link_register).with(arg_hash)
+      @pm.pre_test_link_register(arg_hash)
+    end
+
+    it 'dispatches pre_test_fixture_register to a plugin implementing it, with the given arg_hash' do
+      plugin = stub_plugin_implementing(:pre_test_fixture_register)
+      arg_hash = { tool: 'fake tool' }
+
+      expect(plugin).to receive(:pre_test_fixture_register).with(arg_hash)
+      @pm.pre_test_fixture_register(arg_hash)
+    end
+
+    it 'is a harmless no-op for any of the three when no plugin implements it' do
+      expect { @pm.pre_test_compile_register({}) }.to_not raise_error
+      expect { @pm.pre_test_link_register({}) }.to_not raise_error
+      expect { @pm.pre_test_fixture_register({}) }.to_not raise_error
+    end
+  end
+
+  describe '#explain_test_crash' do
+    before(:each) { allow(@loginator).to receive(:lazy) }
+
+    it 'lets a plugin implementing it name the cause of a crash' do
+      plugin = double('plugin', :name => 'fake')
+      allow(plugin).to receive(:respond_to?).and_return(false)
+      allow(plugin).to receive(:respond_to?).with(:explain_test_crash).and_return(true)
+      allow(plugin).to receive(:explain_test_crash) { |arg_hash| arg_hash[:explanation] = 'ASan heap-buffer-overflow' }
+      @pm.instance_variable_set(:@plugin_objects, [plugin])
+
+      arg_hash = { explanation: nil }
+      @pm.explain_test_crash( arg_hash )
+
+      expect(arg_hash[:explanation]).to eq( 'ASan heap-buffer-overflow' )
+    end
+  end
 end

data/spec/units/plugin_reportinator_spec.rb

@@ -8,6 +8,7 @@
 require 'spec_helper'
 require 'ceedling/constants'
 require 'ceedling/plugins/plugin_reportinator'
+require 'ceedling/templateinator'
 
 describe PluginReportinator do
   before(:each) do
@@ -21,18 +22,92 @@ describe PluginReportinator do
         :plugin_reportinator_helper => @plugin_reportinator_helper,
         :plugin_manager             => @plugin_manager,
         :reportinator               => @reportinator,
-        :loginator                  => @loginator
+        :loginator                  => @loginator,
+        :templateinator             => Templateinator.new
       }
     )
   end
 
   # A build's own test results -- pass or fail -- are core information a user
   # silencing routine build chatter still wants to see, so every plugin that
-  # prints post-build test results (report_tests_stdout_plugin, gcov, valgrind)
-  # shares this one answer instead of each deciding independently.
+  # prints post-build test results (report_tests_stdout_plugin, gcov, bullseye,
+  # valgrind) shares this one answer instead of each deciding independently.
   describe '#test_results_floor_verbosity' do
     it 'is ERRORS' do
       expect( @reportinator_plugin.test_results_floor_verbosity ).to eq( Verbosity::ERRORS )
     end
   end
+
+  describe '#run_test_results_report' do
+    it 'raises a CeedlingException when no template has ever been registered' do
+      expect {
+        @reportinator_plugin.run_test_results_report( { context: TEST_SYM, results: {} } )
+      }.to raise_error( CeedlingException, /No test results report template/ )
+    end
+
+    it 'renders the registered template once one has been set' do
+      @reportinator_plugin.register_test_results_template( 'literal output' )
+      expect(@loginator).to receive(:log).with( 'literal output', Verbosity::NORMAL, LogLabels::NONE )
+
+      @reportinator_plugin.run_test_results_report( { context: TEST_SYM, results: {} } )
+    end
+  end
+
+  describe '#assemble_test_results' do
+    it 'fetches and merges results for every path in the list, in order' do
+      aggregate = nil
+      allow(@plugin_reportinator_helper).to receive(:fetch_results).with('a.pass', {boom: false}).and_return({ marker: :a })
+      allow(@plugin_reportinator_helper).to receive(:fetch_results).with('b.pass', {boom: false}).and_return({ marker: :b })
+      expect(@plugin_reportinator_helper).to receive(:process_results).ordered do |agg, results|
+        aggregate = agg
+        expect(results).to eq({ marker: :a })
+      end
+      expect(@plugin_reportinator_helper).to receive(:process_results).ordered do |agg, results|
+        expect(agg).to equal(aggregate) # same aggregate object threaded through both calls
+        expect(results).to eq({ marker: :b })
+      end
+
+      @reportinator_plugin.assemble_test_results( ['a.pass', 'b.pass'] )
+    end
+  end
+
+  # --- New helper methods below: written to fail until they exist ---
+
+  describe '#test_report_preamble' do
+    it 'extracts the counts a stdout report template needs, plus a context-scoped header prefix' do
+      hash = { context: :gcov, results: { counts: { ignored: 2, failed: 1, stdout: 3 } } }
+
+      expect(@reportinator_plugin.test_report_preamble(hash)).to eq({
+        ignored: 2, failed: 1, stdout_count: 3, header_prepend: 'GCOV: '
+      })
+    end
+
+    it 'uses no header prefix for the default test context' do
+      hash = { context: TEST_SYM, results: { counts: { ignored: 0, failed: 0, stdout: 0 } } }
+
+      expect(@reportinator_plugin.test_report_preamble(hash)[:header_prepend]).to eq('')
+    end
+  end
+
+  describe '#reflow_message' do
+    it 'leaves a single-line message untouched' do
+      expect(@reportinator_plugin.reflow_message("only one line", '  ')).to eq("only one line")
+    end
+
+    it 'prefixes every continuation line, leaving the first line as-is' do
+      expect(@reportinator_plugin.reflow_message("a\nb\nc", '> ')).to eq("a\n> b\n> c")
+    end
+  end
+
+  describe '#decorate_summary_banner' do
+    it 'decorates as FAIL when any test failed' do
+      expect(@loginator).to receive(:decorate).with('OVERALL TEST SUMMARY', LogLabels::FAIL)
+      @reportinator_plugin.decorate_summary_banner('OVERALL TEST SUMMARY', 1)
+    end
+
+    it 'decorates as PASS when nothing failed' do
+      expect(@loginator).to receive(:decorate).with('OVERALL TEST SUMMARY', LogLabels::PASS)
+      @reportinator_plugin.decorate_summary_banner('OVERALL TEST SUMMARY', 0)
+    end
+  end
 end