ceedling 1.1.10 → 1.2.0

data/spec/units/plugins/module_generator_unity_spec.rb

@@ -0,0 +1,37 @@
+# =========================================================================
+#   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'
+
+[File.expand_path( '../../../plugins/module_generator/lib', __dir__ ),
+ File.expand_path( '../../../vendor/unity/auto', __dir__ )].each { |path| $LOAD_PATH.unshift( path ) unless $LOAD_PATH.include?( path ) }
+
+require 'module_generator_unity'
+
+# Only the file plan is exercised here, which Unity builds without touching the disk
+describe ModuleGeneratorUnity do
+
+  def templates(test_guard)
+    generator = described_class.new( path_src: 'src', path_inc: 'inc', path_tst: 'test', test_guard: test_guard )
+    return generator.files_to_operate_on( 'widget' ).to_h { |file| [File.extname( file[:path].to_s ) + file[:path].dirname.to_s, file[:template]] }
+  end
+
+  it 'keeps Unity test template under #ifdef' do
+    expect(templates( 'ifdef' )['.ctest']).to eq( TEMPLATE_TST )
+  end
+
+  it 'guards the test template with #if under the #if guard' do
+    expect(templates( 'if' )['.ctest']).to start_with( "#if %5$s\n" )
+    expect(templates( 'if' )['.ctest']).to eq( TEMPLATE_TST.sub( '#ifdef ', '#if ' ) )
+  end
+
+  it 'leaves source and header templates alone' do
+    expect(templates( 'if' )['.csrc']).to eq( TEMPLATE_SRC )
+    expect(templates( 'if' )['.hinc']).to eq( TEMPLATE_INC )
+  end
+
+end

data/spec/units/plugins/report_build_warnings_log_spec.rb

@@ -0,0 +1,199 @@
+# =========================================================================
+#   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/constants'
+require 'ceedling/plugins/plugin'
+require 'ceedling/exceptions'
+
+$: << File.expand_path('../../../../plugins/report_build_warnings_log/lib', __FILE__)
+require 'report_build_warnings_log'
+
+PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
+
+describe ReportBuildWarningsLog do
+  before(:each) do
+    @file_wrapper = double('file_wrapper')
+    @loginator    = double('loginator')
+    @reportinator = double('reportinator')
+
+    allow(@reportinator).to receive(:generate_heading) { |msg| "HEADING: #{msg}" }
+    allow(@reportinator).to receive(:generate_progress) { |msg| "PROGRESS: #{msg}" }
+    allow(@loginator).to receive(:log)
+
+    @plugin = described_class.allocate
+    @plugin.instance_variable_set(:@warnings, Hash.new)
+    @plugin.instance_variable_set(:@mutex, Mutex.new)
+    @plugin.instance_variable_set(:@basename, 'warnings')
+    @plugin.instance_variable_set(:@reports, WarningReports.load( [:text], version: '1' ))
+    @plugin.instance_variable_set(:@collector, WarningCollector.new)
+    @plugin.instance_variable_set(:@file_wrapper, @file_wrapper)
+    @plugin.instance_variable_set(:@loginator, @loginator)
+    @plugin.instance_variable_set(:@reportinator, @reportinator)
+  end
+
+  # Output without warnings still marks its build context as built, so a structured
+  # report can say that context had none
+  describe '#process_output' do
+    it 'stores no warning, only its build context, when output has no warning-like text' do
+      hash = {}
+      @plugin.send(:process_output, :test, "Compiling foo.c...\nLinking...\n", hash)
+      expect(hash[:test][:collection]).to be_empty
+    end
+  end
+
+  # post_build's public contract -- log a heading, then either report
+  # emptiness or write an artifact per context -- survives the upcoming
+  # base-class refactor unchanged; only the private plumbing underneath
+  # it moves.
+  describe '#post_build' do
+    it 'logs that no warnings were produced and never touches the filesystem when nothing was collected' do
+      expect(@loginator).to receive(:log).with("Build produced no warnings.\n")
+      expect(@file_wrapper).not_to receive(:mkdir)
+      expect(@file_wrapper).not_to receive(:write)
+
+      @plugin.post_build(0)
+    end
+  end
+
+  # Tool output mixes warnings, their context, and unrelated lines
+  describe '#process_output' do
+    it 'stores each warning with its context, leaving out unrelated lines' do
+      hash = {}
+      output = "Compiling foo.c...\nfoo.c: In function 'main':\nfoo.c:3:5: warning: unused variable 'x'\n    3 |   int x;\n"
+
+      @plugin.send(:process_output, :test, output, hash)
+
+      expect(hash[:test][:collection].map( &:text )).to eq(["foo.c: In function 'main':\nfoo.c:3:5: warning: unused variable 'x'\n    3 |   int x;\n"])
+    end
+
+    it 'stores a warning reached through a different include chain only once per context' do
+      hash = {}
+      warning = ->( via ) { "In file included from #{via}:1:\nshared.h:1:12: warning: unused function 'f'\n" }
+
+      @plugin.send(:process_output, :test, warning.call( 'a.c' ), hash)
+      @plugin.send(:process_output, :test, warning.call( 'b.c' ), hash)
+      @plugin.send(:process_output, :release, warning.call( 'b.c' ), hash)
+
+      expect(hash[:test][:collection].map( &:text )).to eq([warning.call( 'a.c' )])
+      expect(hash[:release][:collection].map( &:text )).to eq([warning.call( 'b.c' )])
+    end
+  end
+
+  # A log reaches disk only through the injected file layer
+  describe '#post_build' do
+    it 'joins the collected warning lines for one context and hands them to file_wrapper.write' do
+      @plugin.instance_variable_get(:@warnings)[:test] = {
+        collection: WarningCollector.new.warnings( "foo.c:3:5: warning: unused variable 'x'\nbar.c:9:1: warning: missing return\n" )
+      }
+
+      expect(@file_wrapper).to receive(:mkdir).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test'))
+      expect(@file_wrapper).to receive(:write).with(
+        File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'warnings.log'),
+        "foo.c:3:5: warning: unused variable 'x'\nbar.c:9:1: warning: missing return\n"
+      )
+
+      @plugin.post_build(0)
+    end
+  end
+
+  describe 'configured matching' do
+    def plugin_with(patterns:, excludes:)
+      configurator = double( 'configurator', report_build_warnings_log_filename: 'warnings.log', report_build_warnings_log_reports: [],
+                             report_build_warnings_log_patterns: patterns, report_build_warnings_log_excludes: excludes )
+      plugin = described_class.allocate
+      plugin.instance_variable_set(:@ceedling, { configurator: configurator, file_wrapper: @file_wrapper, loginator: @loginator, reportinator: @reportinator })
+      plugin.setup
+      return plugin
+    end
+
+    it 'collects what configured patterns match and drops what excludes match' do
+      plugin = plugin_with( patterns: [': remark:'], excludes: ['vendor/'] )
+      hash   = {}
+      plugin.send(:process_output, :test, "a.c:1:1: remark: kept\nvendor/b.c:2:1: remark: dropped\na.c:3:1: warning: not a remark\n", hash)
+
+      expect(hash[:test][:collection].map( &:text )).to eq( ["a.c:1:1: remark: kept\n"] )
+    end
+
+    it 'refuses an invalid pattern as it sets up' do
+      expect { plugin_with( patterns: ['bad('], excludes: [] ) }.to raise_error( CeedlingException, /:patterns.*bad\(/ )
+    end
+  end
+
+  # Each configured report is one artifact per build context, named by the configured
+  # filename with the report's own extension
+  describe 'configured reports' do
+    def plugin_with(filename:, reports:)
+      configurator = double( 'configurator', report_build_warnings_log_filename: filename, report_build_warnings_log_reports: reports,
+                             report_build_warnings_log_patterns: [], report_build_warnings_log_excludes: [] )
+      plugin = described_class.allocate
+      plugin.instance_variable_set(:@ceedling, { configurator: configurator, file_wrapper: @file_wrapper, loginator: @loginator, reportinator: @reportinator })
+      plugin.setup
+      return plugin
+    end
+
+    def written
+      files = []
+      allow(@file_wrapper).to receive(:mkdir)
+      allow(@file_wrapper).to receive(:write) { |path, _| files << path }
+      return files
+    end
+
+    it 'writes every report for a context with warnings, replacing the filename extension' do
+      plugin = plugin_with( filename: 'build_warnings.txt', reports: ['sarif', :JSON, :text] )
+      files  = written
+      plugin.post_compile_execute( context: :test, shell_result: { output: "a.c:1:1: warning: w\n" } )
+      plugin.post_build( 0 )
+
+      expect(files).to eq( %w[sarif json log].map { |ext| File.join( 'artifacts', 'test', "build_warnings.#{ext}" ) } )
+    end
+
+    it 'writes structured reports but no text log for a context without warnings' do
+      plugin = plugin_with( filename: 'warnings', reports: [:text, :sarif] )
+      files  = written
+      plugin.post_compile_execute( context: :release, shell_result: { output: "Compiling a.c...\n" } )
+      plugin.post_build( 0 )
+
+      expect(files).to eq( [File.join( 'artifacts', 'release', 'warnings.sarif' )] )
+    end
+
+    it 'says the build produced no warnings, and writes nothing, when only the text log is configured' do
+      plugin = plugin_with( filename: 'warnings', reports: [] )
+      files  = written
+      expect(@loginator).to receive(:log).with( "Build produced no warnings.\n" )
+      plugin.post_compile_execute( context: :test, shell_result: nil )
+      plugin.post_build( 0 )
+
+      expect(files).to be_empty
+    end
+
+    it 'refuses an unknown report as it sets up' do
+      expect { plugin_with( filename: 'warnings', reports: [:xml] ) }.to raise_error( CeedlingException, /`xml`/ )
+    end
+  end
+
+  describe '#setup' do
+    it 'builds a plain Hash, so merely reading an absent context can never silently create an entry' do
+      configurator = double('configurator')
+      allow(configurator).to receive(:report_build_warnings_log_filename).and_return('warnings.log')
+      allow(configurator).to receive(:report_build_warnings_log_patterns).and_return([])
+      allow(configurator).to receive(:report_build_warnings_log_excludes).and_return([])
+      allow(configurator).to receive(:report_build_warnings_log_reports).and_return([:text])
+
+      plugin = described_class.allocate
+      plugin.instance_variable_set(:@ceedling, {
+        configurator: configurator, file_wrapper: @file_wrapper, loginator: @loginator, reportinator: @reportinator
+      })
+      plugin.setup
+
+      warnings = plugin.instance_variable_get(:@warnings)
+      warnings[:some_context_never_written_to]
+
+      expect(warnings).to be_empty
+    end
+  end
+end

data/spec/units/plugins/report_log_writer_plugin_spec.rb

@@ -0,0 +1,94 @@
+# =========================================================================
+#   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/constants'
+require 'ceedling/plugins/plugin'
+require 'ceedling/plugins/report_log_writer_plugin'
+
+# Ceedling normally derives this from project configuration at runtime; the
+# `unless defined?` guard matches the convention already used by other
+# plugin specs (e.g. cppcheck_spec.rb) that need this constant present.
+PROJECT_BUILD_ARTIFACTS_ROOT = 'artifacts' unless defined?(PROJECT_BUILD_ARTIFACTS_ROOT)
+
+# Exercises the shared base directly (not a real subclass) -- proves the
+# mutex/heading/write plumbing correct in isolation before either
+# ReportBuildWarningsLog or ReportTestsRawOutputLog is wired onto it.
+describe ReportLogWriterPlugin do
+  before(:each) do
+    @file_wrapper = double('file_wrapper')
+    @loginator    = double('loginator')
+    @reportinator = double('reportinator')
+
+    allow(@reportinator).to receive(:generate_heading) { |msg| "HEADING: #{msg}" }
+    allow(@reportinator).to receive(:generate_progress) { |msg| "PROGRESS: #{msg}" }
+    allow(@loginator).to receive(:log)
+
+    @plugin = described_class.allocate
+    @plugin.instance_variable_set(:@mutex, Mutex.new)
+    @plugin.instance_variable_set(:@file_wrapper, @file_wrapper)
+    @plugin.instance_variable_set(:@loginator, @loginator)
+    @plugin.instance_variable_set(:@reportinator, @reportinator)
+  end
+
+  describe '#artifact_filepath' do
+    it 'ensures the per-context artifact directory exists and returns the joined filepath' do
+      expect(@file_wrapper).to receive(:mkdir).with(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test'))
+
+      filepath = @plugin.send(:artifact_filepath, :test, 'warnings.log')
+
+      expect(filepath).to eq(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, 'test', 'warnings.log'))
+    end
+  end
+
+  describe '#flush_log' do
+    it 'logs the empty message and never runs the block when empty: reports true' do
+      expect(@loginator).to receive(:log).with('HEADING: Some Report')
+      expect(@loginator).to receive(:log).with("Nothing collected.\n")
+      expect(@loginator).not_to receive(:log).with('')
+
+      ran_block = false
+      @plugin.send(:flush_log, heading: 'Some Report', empty_message: 'Nothing collected.', empty: -> { true }) do
+        ran_block = true
+      end
+
+      expect(ran_block).to be false
+    end
+
+    it 'runs the block and logs trailing whitespace when empty: reports false' do
+      expect(@loginator).to receive(:log).with('HEADING: Some Report')
+      expect(@loginator).to receive(:log).with('')
+
+      ran_block = false
+      @plugin.send(:flush_log, heading: 'Some Report', empty_message: 'Nothing collected.', empty: -> { false }) do
+        ran_block = true
+      end
+
+      expect(ran_block).to be true
+    end
+
+    it "evaluates the empty check and runs the block under the same mutex, so a build thread's write can never interleave with this read" do
+      # A real race would deadlock or corrupt state under this same mutex --
+      # this only proves both sides use it, not that it's impossible to get
+      # wrong, but a regression removing either synchronize would show up
+      # here as a NoMethodError once @mutex is replaced by a non-reentrant
+      # double, or as a flaky failure under a build thread stress test.
+      expect(@plugin.instance_variable_get(:@mutex)).to receive(:synchronize).twice.and_call_original
+
+      @plugin.send(:flush_log, heading: 'Some Report', empty_message: 'Nothing collected.', empty: -> { false }) {}
+    end
+  end
+
+  describe '#write_artifact' do
+    it 'logs progress and writes contents via the injected file_wrapper' do
+      expect(@loginator).to receive(:log).with('PROGRESS: Generating artifact artifacts/test/warnings.log')
+      expect(@file_wrapper).to receive(:write).with('artifacts/test/warnings.log', "line one\nline two\n")
+
+      @plugin.send(:write_artifact, 'artifacts/test/warnings.log', "line one\nline two\n")
+    end
+  end
+end

data/spec/units/plugins/report_tests_gtestlike_stdout_spec.rb

@@ -0,0 +1,274 @@
+# =========================================================================
+#   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/constants'
+require 'ceedling/reportinator'
+require 'ceedling/plugins/plugin_reportinator'
+require 'ceedling/templateinator'
+require 'ceedling/plugins/plugin'
+
+$: << File.expand_path('../../../../plugins/report_tests_gtestlike_stdout/lib', __FILE__)
+$: << File.expand_path('../../../../lib/ceedling/plugins', __FILE__)
+require 'report_tests_gtestlike_stdout'
+
+describe "report_tests_gtestlike_stdout template" do
+  # The plugin's default, overridden where a spec exercises the opt-out
+  let(:ignored_as_skipped) { true }
+
+  before(:each) do
+    @loginator = double('loginator')
+    allow(@loginator).to receive(:decorate) { |str, _label| str }
+
+    @plugin_reportinator = PluginReportinator.new(
+      {
+        plugin_reportinator_helper: nil, plugin_manager: nil,
+        reportinator: Reportinator.new, loginator: @loginator,
+        templateinator: Templateinator.new
+      }
+    )
+    plugin = ReportTestsGtestlikeStdout.allocate
+    plugin.instance_variable_set( :@ignored_as_skipped, ignored_as_skipped )
+    @plugin_reportinator.set_system_objects( { plugin_reportinator: @plugin_reportinator, report_tests_gtestlike_stdout: plugin } )
+
+    template = File.read(File.expand_path('../../../../plugins/report_tests_gtestlike_stdout/assets/test_results.template', __FILE__))
+    @plugin_reportinator.register_test_results_template(template)
+  end
+
+  def render(results)
+    captured = nil
+    allow(@loginator).to receive(:log) { |output, *_| captured = output }
+    @plugin_reportinator.run_test_results_report({ context: TEST_SYM, results: results })
+    captured
+  end
+
+  # A suite with no ignored tests renders every test, so its counts are unambiguous
+
+  let(:pass_fail_only) do
+    {
+      times: { 'test/TestFoo.c' => 0.5 },
+      counts: { total: 2, passed: 1, failed: 1, ignored: 0, stdout: 0 },
+      successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_a', line: 5, message: '' } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' },
+                     collection: [ { test: 'test_b', line: 10, message: 'Expected 1 Was 2.' } ] } ],
+      ignores: []
+    }
+  end
+
+  it 'lists every passed and failed test, with correct header/footer counts, when there are no ignores at all' do
+    output = render(pass_fail_only)
+
+    expect(output).to include('Running 2 tests from 1 test suite.')
+    expect(output).to include('[       OK ] test/TestFoo.c.test_a (0 ms)')
+    expect(output).to include('[  FAILED  ] test/TestFoo.c.test_b (0 ms)')
+    expect(output).to include('[  PASSED  ] 1 test.')
+    expect(output).to include('[  FAILED  ] 1 test, listed below:')
+  end
+
+  # Every reporting plugin receives the same results, so rendering must not alter them
+  it 'leaves the results it renders unaltered' do
+    results = {
+      times: { 'test/TestFoo.c' => 0.5 },
+      counts: { total: 2, passed: 1, failed: 1, ignored: 0, stdout: 0 },
+      successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_a', line: 5, message: '' } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_b', line: 10, message: 'Expected 1 Was 2.' } ] } ],
+      ignores: []
+    }
+    pristine = Marshal.load( Marshal.dump( results ) )
+
+    render(results)
+
+    expect(results).to eq(pristine)
+  end
+
+  describe 'with an ignored test present' do
+    let(:results) do
+      {
+        times: { 'test/TestFoo.c' => 0.5 },
+        counts: { total: 3, passed: 1, failed: 1, ignored: 1, stdout: 0 },
+        successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_a', line: 5, message: '' } ] } ],
+        failures:  [ { source: { file: 'test/TestFoo.c' },
+                       collection: [ { test: 'test_b', line: 10, message: 'Expected 1 Was 2.' } ] } ],
+        ignores:   [ { source: { file: 'test/TestFoo.c' },
+                       collection: [ { test: 'test_ignored', line: 20, message: 'not ready' } ] } ]
+      }
+    end
+
+    # By default an ignored test reports as a GTest skipped test, counted in the run
+    context 'reported as skipped' do
+      it 'lists the ignored test as skipped, with its location and message' do
+        expect( render(results) ).to include( "[ RUN      ] test/TestFoo.c.test_ignored\ntest/TestFoo.c(20): Skipped\nnot ready\n\n[  SKIPPED ] test/TestFoo.c.test_ignored (0 ms)\n" )
+      end
+
+      it 'counts the ignored test in the run and summarizes it as skipped' do
+        output = render(results)
+
+        expect( output ).to include( 'Running 3 tests from 1 test suite.' )
+        expect( output ).to include( "[  PASSED  ] 1 test.\n[  SKIPPED ] 1 test, listed below:\n[  SKIPPED ] test/TestFoo.c.test_ignored\n" )
+      end
+    end
+
+    # The opt-out leaves an ignored test out of the report entirely
+    context 'left out' do
+      let(:ignored_as_skipped) { false }
+
+      it 'never mentions the ignored test at all' do
+        expect( render(results) ).not_to include('test_ignored')
+      end
+
+      it 'reports the header total as passed plus failed' do
+        expect( render(results) ).to include('Running 2 tests from 1 test suite.')
+      end
+
+      it 'still reports the real passed and failed footer counts' do
+        output = render(results)
+
+        expect( output ).to include('[  PASSED  ] 1 test.')
+        expect( output ).to include('[  FAILED  ] 1 test, listed below:')
+      end
+    end
+  end
+
+  # A file's section lists its tests in source order by default
+  it 'lists a file\'s tests in source order' do
+    results = {
+      times: { 'test/TestFoo.c' => 0.5 },
+      counts: { total: 2, passed: 1, failed: 1, ignored: 0, stdout: 0 },
+      successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_late', line: 50, message: '' } ] } ],
+      failures:  [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_early', line: 5, message: 'Expected 1 Was 2.' } ] } ],
+      ignores: []
+    }
+
+    output = render(results)
+
+    expect(output.index('test_early')).to be < output.index('test_late')
+  end
+
+  # Source order holds whether or not ignored tests are reported
+  context 'left out' do
+    let(:ignored_as_skipped) { false }
+
+    it 'still lists a file\'s tests in source order' do
+      results = {
+        times: { 'test/TestFoo.c' => 0.5 },
+        counts: { total: 2, passed: 1, failed: 1, ignored: 0, stdout: 0 },
+        successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_late', line: 50, message: '' } ] } ],
+        failures:  [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_early', line: 5, message: 'Expected 1 Was 2.' } ] } ],
+        ignores: []
+      }
+
+      output = render(results)
+
+      expect(output.index('test_early')).to be < output.index('test_late')
+    end
+  end
+
+  # Sections follow each file's first appearance, successes before failures
+  it 'orders file sections by first appearance among successes, then failures' do
+    results = {
+      times: { 'test/TestA.c' => 0.1, 'test/TestB.c' => 0.2 },
+      counts: { total: 2, passed: 1, failed: 1, ignored: 0, stdout: 0 },
+      successes: [ { source: { file: 'test/TestB.c' }, collection: [ { test: 'test_b', line: 5, message: '' } ] } ],
+      failures:  [ { source: { file: 'test/TestA.c' }, collection: [ { test: 'test_a', line: 5, message: 'Expected 1 Was 2.' } ] } ],
+      ignores: []
+    }
+
+    output = render(results)
+
+    expect(output.index('from test/TestB.c')).to be < output.index('from test/TestA.c')
+  end
+
+  # Durations arrive in seconds and print as whole milliseconds, rounded half up
+  it 'rounds a file\'s duration to whole milliseconds' do
+    results = {
+      times: { 'test/TestFoo.c' => 0.0125 },
+      counts: { total: 1, passed: 1, failed: 0, ignored: 0, stdout: 0 },
+      successes: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_a', line: 5, message: '' } ] } ],
+      failures: [], ignores: []
+    }
+
+    expect(render(results)).to include('test from test/TestFoo.c (13 ms total)')
+  end
+
+  describe 'with a file whose only test is ignored' do
+    let(:results) do
+      {
+        times: { 'test/TestOnlyIgnored.c' => 0.1 },
+        counts: { total: 1, passed: 0, failed: 0, ignored: 1, stdout: 0 },
+        successes: [], failures: [],
+        ignores: [ { source: { file: 'test/TestOnlyIgnored.c' }, collection: [ { test: 'test_ignored', line: 5, message: '' } ] } ]
+      }
+    end
+
+    it 'gives the file a section of skipped tests' do
+      output = render(results)
+
+      expect( output ).to include( "[----------] 1 test from test/TestOnlyIgnored.c\n" )
+      expect( output ).not_to include('No tests executed.')
+    end
+
+    context 'left out' do
+      let(:ignored_as_skipped) { false }
+
+      it 'produces no section for the file at all' do
+        output = render(results)
+
+        expect( output ).not_to include('TestOnlyIgnored')
+        expect( output ).to include('No tests executed.')
+      end
+    end
+  end
+end
+
+describe 'ReportTestsGtestlikeStdout' do
+  def setup_plugin(configured)
+    configurator = double( 'configurator', report_tests_gtestlike_stdout_ignored_as_skipped: configured )
+    file_wrapper = double( 'file_wrapper', exist?: true, read: 'gtest template' )
+    reportinator = double( 'plugin_reportinator', register_test_results_template: nil )
+
+    system_objects = { configurator: configurator, file_wrapper: file_wrapper, plugin_reportinator: reportinator,
+                       file_path_utils: nil, rake_invocation_tracker: nil }
+
+    return ReportTestsGtestlikeStdout.new( system_objects, 'report_tests_gtestlike_stdout', '/plugin' )
+  end
+
+  let(:results) do
+    {
+      times: { 'test/TestFoo.c' => 0.1 },
+      counts: { total: 1, passed: 0, failed: 0, ignored: 1, stdout: 0 },
+      successes: [], failures: [],
+      ignores: [ { source: { file: 'test/TestFoo.c' }, collection: [ { test: 'test_ignored', line: 5, message: '' } ] } ]
+    }
+  end
+
+  # The option arrives through the plugin's defaults and reaches every report it renders
+  it 'reports ignored tests as skipped when configured to' do
+    expect( setup_plugin( true ).gtest_report( { context: TEST_SYM, results: results } ) ).to include('[  SKIPPED ]')
+  end
+
+  it 'leaves ignored tests out when configured not to' do
+    expect( setup_plugin( false ).gtest_report( { context: TEST_SYM, results: results } ) ).not_to include('test_ignored')
+  end
+
+  # A quoted 'false' would otherwise read as true and report ignored tests anyway
+  it 'rejects a setting that is not a boolean' do
+    expect { setup_plugin( 'false' ) }.to raise_error( CeedlingException, /:report_tests_gtestlike_stdout ↳ :ignored_as_skipped/ )
+  end
+
+  # The plugin's whole difference from its siblings is the template asset it ships
+  it 'reports with the template in its own assets directory' do
+    file_wrapper = double('file_wrapper')
+    allow(file_wrapper).to receive(:exist?).with('/plugin/assets/test_results.template').and_return(true)
+    allow(file_wrapper).to receive(:read).with('/plugin/assets/test_results.template').and_return('gtest template')
+
+    plugin = ReportTestsGtestlikeStdout.allocate
+    plugin.instance_variable_set(:@ceedling, { file_wrapper: file_wrapper })
+    plugin.instance_variable_set(:@plugin_root_path, '/plugin')
+
+    expect(plugin.send(:load_template)).to eq('gtest template')
+  end
+end