ceedling 1.1.10 → 1.2.0

data/spec/units/plugins/cppcheck_spec.rb

@@ -363,15 +363,19 @@ describe Cppcheck do
       })
     end
 
-    it 'adds xml and extension glob patterns when path does not exist' do
+    it 'adds xml and extension glob patterns when path does not exist, and warns' do
       allow(file_wrapper).to receive(:exist?).with('missing/').and_return(false)
       expect(file_list).to receive(:include).with('missing/*.xml')
       expect(file_list).to receive(:include).with('missing/*.cfg')
+      # A nonexistent path globs to nothing. Without the warning a typo looks exactly
+      # like a directory holding no suppression files.
+      expect(loginator).to receive(:log).with(/'missing\/' does not exist/, anything, anything)
 
       cppcheck = build_cppcheck(
         config: {},
         file_wrapper: file_wrapper,
-        file_path_collection_utils: file_path_collection_utils
+        file_path_collection_utils: file_path_collection_utils,
+        loginator: loginator
       )
       cppcheck.send(:collect_suppressions, {
         collection_paths_cppcheck: ['missing/'],
@@ -397,6 +401,318 @@ describe Cppcheck do
       expect(result).to have_key(:collection_all_cppcheck)
     end
   end
+
+  # -------------------------------------------------------------------------
+  describe '#validate_environment!' do
+    it 'validates the Cppcheck tool' do
+      stub_const('TOOLS_CPPCHECK', { executable: 'cppcheck' })
+      tool_validator = double('tool_validator')
+      cppcheck = build_cppcheck(config: {})
+      cppcheck.instance_variable_set(:@tool_validator, tool_validator)
+
+      expect(tool_validator).to receive(:validate).with(
+        tool: { executable: 'cppcheck' }, boom: true
+      )
+
+      cppcheck.validate_environment!
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#validate_fail_build_severities' do
+    it 'accepts every severity Cppcheck reports' do
+      cppcheck = build_cppcheck(config: { fail_build_severities: CPPCHECK_SEVERITIES })
+
+      expect { cppcheck.send(:validate_fail_build_severities) }.to_not raise_error
+    end
+
+    it 'accepts an empty list' do
+      cppcheck = build_cppcheck(config: {})
+
+      expect { cppcheck.send(:validate_fail_build_severities) }.to_not raise_error
+    end
+
+    # An unrecognized severity would otherwise silently never match a finding.
+    it 'raises CeedlingException naming the bad value and listing valid severities' do
+      cppcheck = build_cppcheck(config: { fail_build_severities: ['error', 'bogus'] })
+
+      expect { cppcheck.send(:validate_fail_build_severities) }.to raise_error(
+        CeedlingException, /bogus.*'error'.*'warning'.*'information'/m
+      )
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#tally_findings' do
+    def build_tally(contents, exists: true)
+      wrapper = double('file_wrapper', exist?: exists, read: contents)
+      build_cppcheck(config: {}, file_wrapper: wrapper, loginator: loginator)
+    end
+
+    it 'counts findings by severity attribute' do
+      xml = '<results><errors>' \
+            '<error id="a" severity="error" msg="x"></error>' \
+            '<error id="b" severity="style" msg="y"></error>' \
+            '<error id="c" severity="style" msg="z"></error>' \
+            '</errors></results>'
+
+      expect(build_tally(xml).send(:tally_findings, 'r.xml')).to eq({ 'error' => 1, 'style' => 2 })
+    end
+
+    it 'returns an empty tally for a report with no findings' do
+      xml = '<results><errors></errors></results>'
+
+      expect(build_tally(xml).send(:tally_findings, 'r.xml')).to eq({})
+    end
+
+    it 'warns and returns nil when no report was written' do
+      cppcheck = build_tally('', exists: false)
+
+      expect(loginator).to receive(:log).with(/wrote no XML report/, anything, anything)
+      expect(cppcheck.send(:tally_findings, 'r.xml')).to be_nil
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#report_findings' do
+    let(:plugin_manager) { double('plugin_manager', register_build_failure: nil, print_plugin_failures: nil) }
+    let(:application)    { double('application', register_build_failure: nil) }
+
+    def build_reporter(config, contents)
+      wrapper = double('file_wrapper', exist?: true, read: contents)
+      cppcheck = build_cppcheck(config: config, file_wrapper: wrapper, loginator: loginator)
+      cppcheck.instance_variable_set(:@ceedling, {
+        plugin_manager: plugin_manager,
+        application:    application
+      })
+      cppcheck
+    end
+
+    let(:xml_report) { double('xml_report', artifact_filepath: 'r.xml') }
+    let(:one_error)  { '<error id="a" severity="error" msg="x"></error>' }
+
+    it 'does nothing without an XML report' do
+      cppcheck = build_reporter({}, '')
+
+      expect(loginator).to_not receive(:log)
+
+      cppcheck.send(:report_findings, nil)
+    end
+
+    it 'reports that nothing was found for an empty tally' do
+      cppcheck = build_reporter({}, '<results/>')
+
+      expect(loginator).to receive(:log).with(/found no issues/, anything)
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+
+    it 'summarizes findings by severity' do
+      cppcheck = build_reporter({}, one_error)
+
+      expect(loginator).to receive(:log).with(/findings: 1 error/, anything)
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+
+    it 'registers a build failure naming the matching severities when :fail_build is enabled' do
+      cppcheck = build_reporter({ fail_build: true, fail_build_severities: ['error'] }, one_error)
+
+      expect(plugin_manager).to receive(:register_build_failure).with(
+        CPPCHECK_SYM, /1 finding matching :cppcheck.*1 error/
+      )
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+
+    # A cppcheck: task is not one Ceedling treats as a build task, so its end-of-run
+    # handler neither prints the registered failure nor fails the build.
+    it 'prints the failure summary and fails the build itself' do
+      cppcheck = build_reporter({ fail_build: true, fail_build_severities: ['error'] }, one_error)
+
+      expect(plugin_manager).to receive(:print_plugin_failures)
+      expect(application).to receive(:register_build_failure)
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+
+    it 'registers nothing when findings fall outside the configured severities' do
+      cppcheck = build_reporter({ fail_build: true, fail_build_severities: ['portability'] }, one_error)
+
+      expect(plugin_manager).to_not receive(:register_build_failure)
+      expect(application).to_not receive(:register_build_failure)
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+
+    it 'registers nothing when :fail_build is disabled' do
+      cppcheck = build_reporter({ fail_build: false, fail_build_severities: ['error'] }, one_error)
+
+      expect(plugin_manager).to_not receive(:register_build_failure)
+      expect(application).to_not receive(:register_build_failure)
+
+      cppcheck.send(:report_findings, xml_report)
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#build_reports' do
+    before(:each) do
+      stub_const('CPPCHECK_ARTIFACTS_PATH', 'artifacts/cppcheck')
+      stub_const('CPPCHECK_ARTIFACTS_FILE_XML', 'CppcheckReport.xml')
+      stub_const('CPPCHECK_ARTIFACTS_FILE_TEXT', 'CppcheckReport.txt')
+    end
+
+    def build_lazy(config)
+      cppcheck = build_cppcheck(config: config, loginator: loginator)
+      cppcheck.instance_variable_set(:@reports, nil)
+      # Report constructors receive this hash and pull their own collaborators from it.
+      cppcheck.instance_variable_set(:@ceedling, build_system_objects(
+        loginator:      loginator,
+        tool_executor:  double('tool_executor'),
+        tool_validator: double('tool_validator', validate: nil),
+        file_wrapper:   double('file_wrapper')
+      ))
+      cppcheck
+    end
+
+    it 'builds nothing when no report is configured' do
+      expect(build_lazy({ reports: [] }).send(:build_reports)).to eq({})
+    end
+
+    it 'builds the configured report types' do
+      reports = build_lazy({ reports: ['text'] }).send(:build_reports)
+
+      expect(reports.keys).to eq([:text])
+    end
+
+    it 'memoizes so reports are constructed once' do
+      cppcheck = build_lazy({ reports: ['text'] })
+
+      expect(cppcheck.send(:build_reports)).to be(cppcheck.send(:build_reports))
+    end
+
+    # Findings are counted from Cppcheck's own XML, so :fail_build needs that report
+    # to exist. This mirrors how :html already implies :xml.
+    it 'implies an XML report when :fail_build is enabled' do
+      reports = build_lazy({ reports: ['text'], fail_build: true }).send(:build_reports)
+
+      expect(reports.keys).to include(:xml)
+    end
+
+    it 'does not duplicate an XML report already requested' do
+      reports = build_lazy({ reports: ['xml'], fail_build: true }).send(:build_reports)
+
+      expect(reports.keys).to eq([:xml])
+    end
+
+    # HTML needs the XML artifact as its own input, so requesting it implies XML.
+    it 'implies an XML report when HTML is requested' do
+      stub_const('TOOLS_CPPCHECK_HTMLREPORT', { executable: 'cppcheck-htmlreport' })
+      stub_const('CPPCHECK_ARTIFACTS_HTML_PATH', 'artifacts/cppcheck/html')
+
+      reports = build_lazy({ reports: ['html'] }).send(:build_reports)
+
+      expect(reports.keys).to include(:xml, :html)
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#new_report' do
+    it 'logs an error and returns nil for an unrecognized report type' do
+      cppcheck = build_cppcheck(config: {}, loginator: loginator)
+
+      expect(loginator).to receive(:log).with(/'bogus' is not supported/, anything)
+      expect(cppcheck.send(:new_report, :bogus)).to be_nil
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#generate_reports' do
+    before(:each) do
+      stub_const('COLLECTION_PATHS_INCLUDE', ['src'])
+      stub_const('COLLECTION_PATHS_SOURCE', ['src'])
+    end
+
+    def build_generator(config, reports)
+      cppcheck = build_cppcheck(config: config, loginator: loginator)
+      cppcheck.instance_variable_set(:@reports, reports)
+      cppcheck
+    end
+
+    # Cppcheck only runs as part of generating a report. With no report configured
+    # this task analyzed nothing and said nothing, which reads like a clean run.
+    it 'warns and runs nothing when no report is configured' do
+      cppcheck = build_generator({ reports: [], project: nil }, {})
+
+      expect(loginator).to receive(:log).with(/No Cppcheck reports are configured/, anything, anything)
+
+      cppcheck.generate_reports()
+    end
+
+    it 'generates each configured report' do
+      report = double('report', generate: nil, artifact_filepath: 'r.txt')
+      cppcheck = build_generator({ reports: ['text'], project: nil }, { text: report })
+
+      expect(report).to receive(:generate)
+
+      cppcheck.generate_reports()
+    end
+
+    # cppcheck-htmlreport consumes the XML artifact, so XML has to be written first.
+    it 'generates the XML report before the HTML report' do
+      order = []
+      xml  = double('xml',  artifact_filepath: 'r.xml')
+      html = double('html', artifact_filepath: 'html')
+      allow(xml).to receive(:generate)  { order << :xml }
+      allow(html).to receive(:generate) { order << :html }
+
+      cppcheck = build_generator({ reports: ['html'], project: nil }, { html: html, xml: xml })
+      allow(cppcheck).to receive(:report_findings)
+
+      cppcheck.generate_reports()
+
+      expect(order).to eq([:xml, :html])
+    end
+
+    # :project hands source and include discovery to Cppcheck itself.
+    it 'passes no Ceedling source or include paths when :project is configured' do
+      report = double('report', artifact_filepath: 'r.txt')
+      cppcheck = build_generator({ reports: ['text'], project: 'compile_commands.json' }, { text: report })
+
+      expect(report).to receive(:generate).with(anything, [], [])
+
+      cppcheck.generate_reports()
+    end
+
+    it 'passes Ceedling source and include paths when :project is not configured' do
+      report = double('report', artifact_filepath: 'r.txt')
+      cppcheck = build_generator({ reports: ['text'], project: nil }, { text: report })
+
+      expect(report).to receive(:generate).with(anything, ['src'], ['src'])
+
+      cppcheck.generate_reports()
+    end
+  end
+
+  # -------------------------------------------------------------------------
+  describe '#analyze_file' do
+    before(:each) { stub_const('COLLECTION_PATHS_INCLUDE', ['src']) }
+
+    it 'runs Cppcheck against the single file and logs its output' do
+      stub_const('TOOLS_CPPCHECK', { executable: 'cppcheck' })
+      reportinator = double('reportinator', generate_progress: 'PROGRESS')
+      cppcheck = build_cppcheck(config: { enable_checks: ['style'] }, loginator: loginator)
+      cppcheck.instance_variable_set(:@reportinator, reportinator)
+
+      expect(cppcheck).to receive(:run_tool).with(
+        { executable: 'cppcheck' }, ['--enable=style'], ['src'], 'src/thing.c'
+      ).and_return({ output: 'FINDINGS' })
+      expect(loginator).to receive(:log).with('FINDINGS', anything, anything)
+
+      cppcheck.analyze_file('src/thing.c')
+    end
+  end
 end
 
 # ===========================================================================
@@ -419,8 +735,15 @@ describe CppcheckXmlReport do
     stub_const('CPPCHECK_ARTIFACTS_FILE_XML', 'CppcheckReport.xml')
   end
 
-  it 'uses --xml-version=3 by default' do
+  # Version 2 is accepted by every Cppcheck. Version 3 requires a newer Cppcheck and
+  # is rejected outright by older ones, so it is not a safe default.
+  it 'uses --xml-version=2 by default' do
     report = described_class.new(system_objects, {})
+    expect(report.send(:build_opts)).to include('--xml', '--xml-version=2')
+  end
+
+  it 'uses --xml-version=3 when version 3 is requested' do
+    report = described_class.new(system_objects, { xml_report_version: 3 })
     expect(report.send(:build_opts)).to include('--xml', '--xml-version=3')
   end
 
@@ -495,9 +818,12 @@ describe CppcheckHtmlReport do
     expect(report.send(:build_opts)).not_to include(a_string_starting_with('--title'))
   end
 
-  it 'validates the htmlreport tool during initialization' do
+  # respect_optional honors the tool's own `:optional => true` default, so a missing
+  # cppcheck-htmlreport does not hard-fail a build that never generates HTML.
+  it 'validates the htmlreport tool during initialization, respecting its optional flag' do
     expect(tool_validator).to receive(:validate).with(
       tool: { executable: 'cppcheck-htmlreport' },
+      respect_optional: true,
       boom: true
     )
     build_html_report

data/spec/units/plugins/cppunit_tests_reporter_spec.rb

@@ -0,0 +1,118 @@
+# =========================================================================
+#   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 'stringio'
+require 'rexml/document'
+
+$: << File.expand_path('../../../../plugins/report_tests_log_factory/lib', __FILE__)
+require 'cppunit_tests_reporter'
+
+describe CppunitTestsReporter do
+  let(:reporter) { described_class.new(handle: :cppunit) }
+
+  let(:results) do
+    {
+      successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_a' } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_b', line: 30, message: 'Expected 1 Was 2' } ] } ],
+      ignores:   [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_c' } ] } ],
+      counts: { total: 3, passed: 1, failed: 1, ignored: 1 }
+    }
+  end
+
+  describe 'full render' do
+    reporter_calls = ->(reporter, stream, results) do
+      reporter.header(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+      reporter.body(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+      reporter.footer(stream: stream, name: 'Ceedling Test Suite', results: results, duration_s: nil)
+    end
+
+    it 'nests failed/successful/ignored tests correctly, always reporting zero Errors' do
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, results)
+
+      doc = REXML::Document.new(stream.string)
+      root = doc.root
+      expect(root.name).to eq('TestRun')
+
+      failed_name = root.elements['FailedTests/Test/Name'].text
+      expect(failed_name).to eq('test/TestFoo.c::test_b')
+      expect(root.elements['FailedTests/Test/Message'].text).to eq('Expected 1 Was 2')
+
+      expect(root.elements['SuccessfulTests/Test/Name'].text).to eq('test/TestFoo.c::test_a')
+      expect(root.elements['IgnoredTests/Test/Name'].text).to eq('test/TestFoo.c::test_c')
+
+      expect(root.elements['Statistics/Tests'].text).to eq('3')
+      expect(root.elements['Statistics/Ignores'].text).to eq('1')
+      expect(root.elements['Statistics/FailuresTotal'].text).to eq('1')
+      expect(root.elements['Statistics/Errors'].text).to eq('0')
+    end
+
+    it 'self-closes each section when its result list is empty' do
+      empty_results = { successes: [], failures: [], ignores: [], counts: { total: 0, passed: 0, failed: 0, ignored: 0 } }
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, empty_results)
+
+      expect(stream.string).to include('<FailedTests/>')
+      expect(stream.string).to include('<SuccessfulTests/>')
+      expect(stream.string).to include('<IgnoredTests/>')
+    end
+
+    it 'escapes XML metacharacters in the test name and message' do
+      escaping_results = {
+        successes: [], ignores: [],
+        failures: [ { source: { file: 'test/TestFoo.c' },
+                      collection: [ { test: 'test<b>', line: 30, message: 'Expected "<a>" & more' } ] } ],
+        counts: { total: 1, passed: 0, failed: 1, ignored: 0 }
+      }
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, escaping_results)
+
+      doc = REXML::Document.new(stream.string) # raises REXML::ParseException on malformed XML
+      test = doc.root.elements['FailedTests/Test']
+      expect(test.elements['Name'].text).to eq('test/TestFoo.c::test<b>')
+      expect(test.elements['Message'].text).to eq('Expected "<a>" & more')
+    end
+
+    it 'locates a failure by file and line' do
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, results)
+
+      location = REXML::Document.new(stream.string).root.elements['FailedTests/Test/Location']
+      expect(location.elements['File'].text).to eq('test/TestFoo.c')
+      expect(location.elements['Line'].text).to eq('30')
+    end
+
+    it 'numbers every test in one sequence across all sections' do
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, results)
+
+      ids = REXML::Document.new(stream.string).root.get_elements('//Test').map { |test| test.attributes['id'] }
+      expect(ids).to eq(['1', '2', '3'])
+    end
+
+    it 'reports the statistics from the aggregated counts' do
+      stream = StringIO.new
+      reporter_calls.call(reporter, stream, results)
+
+      stats = REXML::Document.new(stream.string).root.elements['Statistics']
+      expect(stats.elements['Tests'].text).to eq('3')
+      expect(stats.elements['Ignores'].text).to eq('1')
+      expect(stats.elements['FailuresTotal'].text).to eq('1')
+    end
+
+    it 'escapes the report name' do
+      stream = StringIO.new
+      reporter.header(stream: stream, name: 'Q-36 & <Modulator>', results: results, duration_s: nil)
+      reporter.body(stream: stream, name: 'Q-36 & <Modulator>', results: results, duration_s: nil)
+      reporter.footer(stream: stream, name: 'Q-36 & <Modulator>', results: results, duration_s: nil)
+
+      expect(REXML::Document.new(stream.string).root.attributes['name']).to eq('Q-36 & <Modulator>')
+    end
+  end
+end