ceedling 1.1.10 → 1.2.0

data/spec/units/plugins/warning_collector_spec.rb

@@ -0,0 +1,185 @@
+# =========================================================================
+#   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'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/report_build_warnings_log/lib', __dir__ ) )
+
+require 'ceedling/exceptions'
+require 'warning_collector'
+
+describe WarningCollector do
+
+  # Clang, as Apple's toolchain prints a header warning and a local one
+  CLANG = <<~OUT
+    a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]
+    int a( void ) { int spare; return 0; }
+                        ^
+    In file included from a.c:1:
+    ./shared.h:1:12: warning: unused function 'unused_helper' [-Wunused-function]
+    static int unused_helper( void ) { return 1; }
+               ^
+    2 warnings generated.
+  OUT
+
+  # GCC, with its function context, numbered source lines, and a note
+  GCC = <<~OUT
+    a.c: In function 'a':
+    a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]
+        2 | int a( void ) { int spare; return 0; }
+          |                     ^~~~~
+    a.c:9:3: warning: 'x' may be used uninitialized [-Wmaybe-uninitialized]
+        9 |   return x;
+          |   ^~~~~~
+    a.c:8:7: note: 'x' was declared here
+        8 |   int x;
+          |       ^
+  OUT
+
+  let(:collector) { described_class.new }
+
+  it 'keeps each warning with the context lines that belong to it' do
+    expect(collector.warnings( CLANG ).map( &:text )).to eq( [
+      "a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]\nint a( void ) { int spare; return 0; }\n                    ^\n",
+      "In file included from a.c:1:\n./shared.h:1:12: warning: unused function 'unused_helper' [-Wunused-function]\nstatic int unused_helper( void ) { return 1; }\n           ^\n"
+    ] )
+  end
+
+  it 'keeps a function context line and a following note with their warning' do
+    warnings = collector.warnings( GCC ).map( &:text )
+
+    expect(warnings.size).to eq( 2 )
+    expect(warnings.first).to start_with( "a.c: In function 'a':\na.c:2:21: warning: unused variable" )
+    expect(warnings.last).to include( "note: 'x' was declared here", '   |       ^' )
+  end
+
+  it 'leaves out a compiler summary line that only counts warnings' do
+    expect(collector.warnings( "1 warning generated.\n3 warnings and 1 error generated.\n" )).to be_empty
+  end
+
+  it 'leaves out errors, keeping a warning that follows one' do
+    output = "a.c:1:1: error: unknown type name 'foo'\nfoo x;\n^\na.c:2:5: warning: unused variable 'y'\nint y;\n    ^\n"
+
+    expect(collector.warnings( output ).map( &:text )).to eq( ["a.c:2:5: warning: unused variable 'y'\nint y;\n    ^\n"] )
+  end
+
+  it 'takes single lines from output in other formats' do
+    output = "ld: warning: object file was built for a newer OS\n\"main.c\",3  Warning[Pe177]: variable \"x\" was declared but never referenced\nLinking...\n"
+
+    expect(collector.warnings( output ).map( &:text )).to eq( [
+      "ld: warning: object file was built for a newer OS\n",
+      "\"main.c\",3  Warning[Pe177]: variable \"x\" was declared but never referenced\n"
+    ] )
+  end
+
+  it 'finds nothing in output without warnings' do
+    expect(collector.warnings( "Compiling a.c...\n" )).to be_empty
+  end
+
+  it 'gives a warning the same identity whichever file included its header' do
+    via_b = CLANG.sub( 'In file included from a.c:1:', 'In file included from b.c:1:' )
+    header_warning = ->( output ) { collector.warnings( output ).last }
+
+    expect(collector.identity( header_warning.call( via_b ) )).to eq( collector.identity( header_warning.call( CLANG ) ) )
+    expect(collector.identity( header_warning.call( CLANG ) )).not_to include( 'In file included from' )
+  end
+
+  describe 'warning records' do
+    it 'parses a GCC diagnostic into its location, severity, message, flag, and context' do
+      warning = collector.warnings( GCC ).first
+
+      expect(warning.to_h).to eq(
+        file: 'a.c', line: 2, column: 21, severity: 'warning', message: "unused variable 'spare'",
+        flag: '-Wunused-variable', context: ["a.c: In function 'a':"],
+        text: "a.c: In function 'a':\na.c:2:21: warning: unused variable 'spare' [-Wunused-variable]\n" \
+              "    2 | int a( void ) { int spare; return 0; }\n      |                     ^~~~~\n"
+      )
+    end
+
+    it 'keeps every context line before a header warning' do
+      expect(collector.warnings( CLANG ).last.context).to eq( ['In file included from a.c:1:'] )
+    end
+
+    it 'reads a Windows path with its drive letter and a diagnostic with no column or flag' do
+      warning = collector.warnings( "C:\\proj\\src\\a.c:7: warning: implicit declaration\n" ).first
+
+      expect([warning.file, warning.line, warning.column, warning.flag, warning.message])
+        .to eq( ['C:\\proj\\src\\a.c', 7, nil, nil, 'implicit declaration'] )
+    end
+
+    it 'takes as its flag only a bracketed option, leaving older GCC notes in the message' do
+      warning = collector.warnings( "a.c:3:1: warning: 'f' declared but never defined [enabled by default]\n" ).first
+
+      expect([warning.flag, warning.message]).to eq( [nil, "'f' declared but never defined [enabled by default]"] )
+    end
+
+    it 'gives output in another format only its text and message' do
+      warning = collector.warnings( "ld: warning: object file was built for a newer OS\n" ).first
+
+      expect(warning.to_h).to eq(
+        file: nil, line: nil, column: nil, severity: nil, message: 'ld: warning: object file was built for a newer OS',
+        flag: nil, context: [], text: "ld: warning: object file was built for a newer OS\n"
+      )
+    end
+  end
+
+  describe '.compile' do
+    it 'makes regular expressions of configured strings' do
+      expect(described_class.compile( [': remark:', '(?i)WARN'], setting: ':patterns' )).to eq( [/: remark:/, /(?i)WARN/] )
+    end
+
+    it 'refuses an invalid expression, naming its setting and itself' do
+      expect { described_class.compile( ['ok', 'bad('], setting: ':report_build_warnings_log ↳ :excludes' ) }
+        .to raise_error( CeedlingException, /:excludes.*`bad\(`/ )
+    end
+
+    it 'refuses an entry that is not a string' do
+      expect { described_class.compile( [42], setting: ':patterns' ) }.to raise_error( CeedlingException, /`42`/ )
+    end
+  end
+
+  # GCC 14 reports a header's warning after a function's warning with an `At top level`
+  # line it leaves out when nothing came before
+  it 'gives a warning the same identity whatever scope line GCC puts before it' do
+    after_function = <<~OUT
+      a.c: In function ‘a’:
+      a.c:2:21: warning: unused variable ‘spare’ [-Wunused-variable]
+          2 | int a( void ) { int spare; return 0; }
+            |                     ^~~~~
+      In file included from a.c:1:
+      shared.h: At top level:
+      shared.h:1:12: warning: ‘unused_helper’ defined but not used [-Wunused-function]
+          1 | static int unused_helper( void ) { return 1; }
+            |            ^~~~~~~~~~~~~
+    OUT
+    alone = <<~OUT
+      In file included from b.c:1:
+      shared.h:1:12: warning: ‘unused_helper’ defined but not used [-Wunused-function]
+          1 | static int unused_helper( void ) { return 1; }
+            |            ^~~~~~~~~~~~~
+    OUT
+
+    expect(collector.identity( collector.warnings( after_function ).last )).to eq( collector.identity( collector.warnings( alone ).last ) )
+  end
+
+  describe 'configured matching' do
+    it 'collects what custom patterns match instead of warnings' do
+      remarks = described_class.new( patterns: [/: remark:/] )
+      output  = "a.c:3:1: remark: loop not vectorized\na.c:4:1: warning: unused variable 'z'\n"
+
+      expect(remarks.warnings( output ).map( &:text )).to eq( ["a.c:3:1: remark: loop not vectorized\n"] )
+    end
+
+    it 'drops warnings any exclude matches, anywhere in their text' do
+      excluding = described_class.new( excludes: [/unused_helper/, %r{third_party/}] )
+      output    = CLANG + "In file included from b.c:1:\nthird_party/lib.h:9:1: warning: deprecated\n"
+
+      expect(excluding.warnings( output ).map( &:text ).map( &:lines ).map( &:first )).to eq( ["a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]\n"] )
+    end
+  end
+
+end

data/spec/units/plugins/warning_reports_spec.rb

@@ -0,0 +1,150 @@
+# =========================================================================
+#   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 'json'
+
+$LOAD_PATH.unshift( File.expand_path( '../../../plugins/report_build_warnings_log/lib', __dir__ ) )
+
+require 'ceedling/exceptions'
+require 'warning_collector'
+require 'warning_reports'
+
+describe WarningReports do
+
+  # A compile's GCC warning with a function context, and a link's warning in no known format
+  WARNING_REPORTS_COMPILE = <<~OUT.freeze
+    src/a.c: In function 'a':
+    src/a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]
+        2 | int a( void ) { int spare; return 0; }
+          |                     ^~~~~
+  OUT
+  WARNING_REPORTS_LINK = "ld: warning: object file was built for a newer OS\n".freeze
+
+  let(:records) { [WARNING_REPORTS_COMPILE, WARNING_REPORTS_LINK].flat_map { |output| WarningCollector.new.warnings( output ) } }
+
+  def report(name)
+    return described_class.load( [name], version: '9.9.9' ).first
+  end
+
+  describe '.load' do
+    it 'is the text report alone when no reports are configured' do
+      [nil, []].each do |entries|
+        expect(described_class.load( entries, version: '1' ).map( &:extension )).to eq( ['log'] )
+      end
+    end
+
+    it 'takes symbols or strings in any letter case, each report once' do
+      expect(described_class.load( [:sarif, 'JSON', 'sarif', :text], version: '1' ).map( &:extension )).to eq( %w[sarif json log] )
+    end
+
+    it 'refuses an unknown report, naming it and the choices' do
+      expect { described_class.load( [:text, :xml], version: '1' ) }
+        .to raise_error( CeedlingException, /`xml`.*:text, :sarif, :json/ )
+    end
+
+    it 'refuses an entry that is neither a symbol nor a string' do
+      expect { described_class.load( [42], version: '1' ) }.to raise_error( CeedlingException, /`42`/ )
+    end
+  end
+
+  describe '.basename' do
+    it 'drops any extension from the configured filename' do
+      expect(%w[warnings warnings.log more.better.ext].map { |name| described_class.basename( name ) })
+        .to eq( %w[warnings warnings more.better] )
+    end
+  end
+
+  describe 'text report' do
+    it 'is each warning as the tools printed it' do
+      expect(report( :text ).render( :test, records )).to eq( WARNING_REPORTS_COMPILE + WARNING_REPORTS_LINK )
+    end
+
+    it 'is not written for a build context without warnings' do
+      expect(report( :text ).write_empty?).to be false
+    end
+  end
+
+  describe 'JSON report' do
+    it 'lists each warning with its parsed fields under its build context' do
+      json = JSON.parse( report( :json ).render( :test, records ) )
+
+      expect(json['context']).to eq( 'test' )
+      expect(json['warnings'].first).to eq(
+        'file' => 'src/a.c', 'line' => 2, 'column' => 21, 'severity' => 'warning', 'flag' => '-Wunused-variable',
+        'message' => "unused variable 'spare'", 'context' => ["src/a.c: In function 'a':"],
+        'text' => "src/a.c: In function 'a':\nsrc/a.c:2:21: warning: unused variable 'spare' [-Wunused-variable]\n" \
+                  "    2 | int a( void ) { int spare; return 0; }\n      |                     ^~~~~\n"
+      )
+      expect(json['warnings'].last).to include( 'file' => nil, 'message' => 'ld: warning: object file was built for a newer OS' )
+    end
+
+    it 'is written, with no warnings, for a build context without any' do
+      expect(report( :json ).write_empty?).to be true
+      expect(JSON.parse( report( :json ).render( :release, [] ) )).to eq( 'context' => 'release', 'warnings' => [] )
+    end
+  end
+
+  describe 'SARIF report' do
+    let(:sarif) { JSON.parse( report( :sarif ).render( :test, records ) ) }
+    let(:run)   { sarif['runs'].first }
+
+    it 'is one SARIF 2.1.0 run by Ceedling, identified by its build context' do
+      expect(sarif).to include( 'version' => '2.1.0', '$schema' => 'https://json.schemastore.org/sarif-2.1.0.json' )
+      expect(sarif['runs'].size).to eq( 1 )
+      expect(run['tool']['driver']).to include( 'name' => 'Ceedling', 'version' => '9.9.9' )
+      expect(run['tool']['driver']['rules']).to eq( [{ 'id' => '-Wunused-variable' }] )
+      expect(run['automationDetails']).to eq( 'id' => 'test/' )
+    end
+
+    it 'makes a GCC warning a result with its flag as rule, its level, message, and location' do
+      expect(run['results'].first).to eq(
+        'ruleId'     => '-Wunused-variable',
+        'level'      => 'warning',
+        'message'    => { 'text' => "unused variable 'spare'" },
+        'locations'  => [{ 'physicalLocation' => {
+          'artifactLocation' => { 'uri' => 'src/a.c', 'uriBaseId' => '%SRCROOT%' },
+          'region'           => { 'startLine' => 2, 'startColumn' => 21 }
+        } }],
+        'properties' => { 'context' => ["src/a.c: In function 'a':"], 'text' => records.first.text }
+      )
+    end
+
+    it 'makes output in another format a result with only its message' do
+      expect(run['results'].last).to eq(
+        'message'    => { 'text' => 'ld: warning: object file was built for a newer OS' },
+        'properties' => { 'context' => [], 'text' => "ld: warning: object file was built for a newer OS\n" }
+      )
+    end
+
+    it 'gives each severity its SARIF level' do
+      output = "a.c:1:1: remark: r\na.c:2:1: note: n\nb.c:3:1: warning: w\n"
+      levels = WarningCollector.new( patterns: [/./] ).warnings( output ).then { |all| JSON.parse( report( :sarif ).render( :test, all ) ) }
+                                .dig( 'runs', 0, 'results' ).map { |result| result['level'] }
+
+      expect(levels).to eq( %w[note warning] )
+    end
+
+    it 'locates a path as a project URI with forward slashes and no leading ./, and an absolute path as a file URI' do
+      output  = "src\\sub dir\\a.c:4:2: warning: w\nC:\\proj\\b.c:5:1: warning: x\n/home/me/c.c:6:1: warning: y\n./inc/d.h:7:1: warning: z\n"
+      results = JSON.parse( report( :sarif ).render( :test, WarningCollector.new.warnings( output ) ) ).dig( 'runs', 0, 'results' )
+
+      expect(results.map { |result| result.dig( 'locations', 0, 'physicalLocation', 'artifactLocation' ) }).to eq( [
+        { 'uri' => 'src/sub%20dir/a.c', 'uriBaseId' => '%SRCROOT%' },
+        { 'uri' => 'file:///C:/proj/b.c' },
+        { 'uri' => 'file:///home/me/c.c' },
+        { 'uri' => 'inc/d.h', 'uriBaseId' => '%SRCROOT%' }
+      ] )
+    end
+
+    it 'is written, with no results, for a build context without warnings' do
+      expect(report( :sarif ).write_empty?).to be true
+      expect(JSON.parse( report( :sarif ).render( :test, [] ) ).dig( 'runs', 0, 'results' )).to eq( [] )
+    end
+  end
+
+end

data/spec/units/preprocess/c_comment_scanner_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe CCommentScanner do
   # Helper: extract the matched text for every CommentInfo in content
   # ---------------------------------------------------------------------------
   def comment_texts(content, infos)
-    infos.map { |info| content[info.position, info.length] }
+    infos.map { |info| content[info.position, info.byte_count] }
   end
 
 
@@ -63,7 +63,7 @@ RSpec.describe CCommentScanner do
 
         expect(infos.length).to eq(1)
         expect(infos[0].position).to eq(11)
-        expect(content[infos[0].position, infos[0].length]).to eq('// assign x')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// assign x')
         expect(infos[0].lines_removed).to eq(0)
       end
 
@@ -72,7 +72,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq('// eof comment')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// eof comment')
         expect(infos[0].lines_removed).to eq(0)
       end
 
@@ -82,7 +82,7 @@ RSpec.describe CCommentScanner do
 
         expect(infos.length).to eq(1)
         # The \n at position 10 must remain available; only the comment is captured
-        expect(content[infos[0].position, infos[0].length]).to eq('// comment')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// comment')
         expect(infos[0].lines_removed).to eq(0)
       end
 
@@ -92,7 +92,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("// first line \\\nsecond line still comment")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("// first line \\\nsecond line still comment")
         expect(infos[0].lines_removed).to eq(1)
       end
 
@@ -102,7 +102,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("// first line \\   \nsecond line still comment")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("// first line \\   \nsecond line still comment")
         expect(infos[0].lines_removed).to eq(1)
       end
 
@@ -113,7 +113,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("// comment\\\t\t\ncontinuation")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("// comment\\\t\t\ncontinuation")
         expect(infos[0].lines_removed).to eq(1)
       end
 
@@ -122,7 +122,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("// line one \\\nline two \\\nline three")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("// line one \\\nline two \\\nline three")
         expect(infos[0].lines_removed).to eq(2)
       end
 
@@ -138,7 +138,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq('/* the value */')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('/* the value */')
         expect(infos[0].lines_removed).to eq(0)
       end
 
@@ -154,7 +154,7 @@ RSpec.describe CCommentScanner do
 
         expect(infos.length).to eq(1)
         expect(infos[0].position).to eq(0)
-        expect(content[infos[0].position, infos[0].length]).to eq("/*\n * Module: sensor\n * Version: 2.1\n */")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("/*\n * Module: sensor\n * Version: 2.1\n */")
         expect(infos[0].lines_removed).to eq(3)
       end
 
@@ -163,7 +163,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("/* unterminated block\nstill in comment\n")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("/* unterminated block\nstill in comment\n")
         expect(infos[0].lines_removed).to eq(2)
       end
 
@@ -172,7 +172,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq("/* block with // inside\nstill block */")
+        expect(content[infos[0].position, infos[0].byte_count]).to eq("/* block with // inside\nstill block */")
         expect(infos[0].lines_removed).to eq(1)
       end
 
@@ -200,7 +200,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq('// real comment')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// real comment')
       end
 
       it 'handles an escaped quote inside a string literal before a real comment' do
@@ -209,7 +209,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq('// real comment')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// real comment')
       end
 
     end
@@ -224,7 +224,7 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(1)
-        expect(content[infos[0].position, infos[0].length]).to eq('// line comment /* not a block')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('// line comment /* not a block')
         expect(infos[0].lines_removed).to eq(0)
       end
 
@@ -233,8 +233,8 @@ RSpec.describe CCommentScanner do
         infos   = scanner.scan(io: StringIO.new(content))
 
         expect(infos.length).to eq(2)
-        expect(content[infos[0].position, infos[0].length]).to eq('/* block */')
-        expect(content[infos[1].position, infos[1].length]).to eq('/* another block */')
+        expect(content[infos[0].position, infos[0].byte_count]).to eq('/* block */')
+        expect(content[infos[1].position, infos[1].byte_count]).to eq('/* another block */')
       end
 
       it 'finds all comments in realistic mixed-comment C code in correct order' do

data/spec/units/preprocess/c_preprocessor_conditionals_spec.rb

@@ -175,6 +175,93 @@ RSpec.describe CPreprocessorConditionals do
       expect(t.active?).to be true
     end
 
+    it 'treats #if defined(A) && defined(B) as active even when A is not defined' do
+      # A coincidentally-passing version of this case with A defined exists above --
+      # it can't distinguish "correctly conservative" from "matched defined(A) alone
+      # and A happens to be true." Only an undefined first macro tells them apart.
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if defined(A) && defined(B)')
+      expect(t.active?).to be true
+    end
+
+    it 'treats #if !defined(A) || defined(B) as active even when A is defined' do
+      t = CPreprocessorConditionals.new(['A'])
+      t.process_directive('#if !defined(A) || defined(B)')
+      expect(t.active?).to be true
+    end
+
+  end
+
+
+  # ===========================================================================
+  describe '#unevaluated?' do
+  # ===========================================================================
+
+    # `active?` cannot distinguish a condition this tracker decided from one it kept without
+    # evaluating. A guess is the right default for skipping text and the wrong basis for
+    # relocating a type definition, so a caller that relocates content needs to tell them apart.
+
+    it 'is false at the top level' do
+      expect(CPreprocessorConditionals.new([]).unevaluated?).to be false
+    end
+
+    it 'is false inside a condition it decided' do
+      t = CPreprocessorConditionals.new(['A'])
+      ['#ifdef A', '#ifndef B', '#if 0', '#if 1', '#if defined(A)', '#if !defined(B)'].each do |directive|
+        t.reset
+        t.process_directive(directive)
+        expect(t.unevaluated?).to be(false), "#{directive} should be decided, not guessed"
+      end
+    end
+
+    it 'is true inside a complex #if it kept without evaluating' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if defined(A) && defined(B)')
+      expect(t.unevaluated?).to be true
+    end
+
+    it 'is true inside a complex #elif it kept without evaluating' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#ifdef A')
+      t.process_directive('#elif VERSION >= 3')
+      expect(t.unevaluated?).to be true
+    end
+
+    # The flag belongs to the frame, so it goes away with it rather than contaminating whatever
+    # follows the block.
+    it 'is false again once the block closes' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if VERSION >= 3')
+      t.process_directive('#endif')
+      expect(t.unevaluated?).to be false
+    end
+
+    # An #else arm of an unevaluable conditional is no more decided than the #if arm was: which
+    # arm is live was never established.
+    it 'stays true across the #else of an unevaluable conditional' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if defined(A) && defined(B)')
+      t.process_directive('#else')
+      expect(t.unevaluated?).to be true
+    end
+
+    it 'is true for a decided outer block holding an unevaluable inner one' do
+      t = CPreprocessorConditionals.new(['A'])
+      t.process_directive('#ifdef A')
+      t.process_directive('#if VERSION >= 3')
+      expect(t.unevaluated?).to be true
+
+      t.process_directive('#endif')
+      expect(t.unevaluated?).to be false
+    end
+
+    it 'is cleared by #reset' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if VERSION >= 3')
+      t.reset
+      expect(t.unevaluated?).to be false
+    end
+
   end
 
 
@@ -270,6 +357,13 @@ RSpec.describe CPreprocessorConditionals do
       expect(t.active?).to be true
     end
 
+    it 'treats #elif defined(A) && defined(B) as active when prior branch inactive, even when A is not defined' do
+      t = CPreprocessorConditionals.new([])
+      t.process_directive('#if 0')
+      t.process_directive('#elif defined(A) && defined(B)')
+      expect(t.active?).to be true
+    end
+
     it 'activates #else after #elif was inactive' do
       t = CPreprocessorConditionals.new([])
       t.process_directive('#if 0')

data/spec/units/preprocess/preprocessinator_bare_includes_extractor_spec.rb

@@ -0,0 +1,73 @@
+# =========================================================================
+#   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/preprocess/preprocessinator_bare_includes_extractor'
+require 'ceedling/includes/includes'
+
+# PreprocessinatorBareIncludesExtractor is a pure parser: it turns the `gcc -M -MG -MP`
+# "phony" make rules -- one `header:` line per dependency -- into bare Include objects.
+# The handler that runs GCC (PreprocessinatorIncludesHandler#extract_bare_includes)
+# gates on MAKE_RULE_MATCHER first and hands only matching output here, so these tests
+# feed representative make-rule text directly.
+describe PreprocessinatorBareIncludesExtractor do
+  def extract(text) = described_class.extract_includes(text)
+
+  it 'returns one bare Include per phony rule line' do
+    rules = <<~RULES
+      widget.o: widget.c widget.h stdint.h
+      widget.h:
+      stdint.h:
+    RULES
+    result = extract(rules)
+    expect(result.map(&:filename)).to eq(['widget.h', 'stdint.h'])
+    expect(result).to all(be_an_instance_of(Include))
+  end
+
+  it 'produces no includes from a make rule with no phony lines (file has no #includes)' do
+    expect(extract("solo.o: solo.c\n")).to eq([])
+  end
+
+  it 'captures a phony rule for a pathful dependency' do
+    rules = <<~RULES
+      os.o: ../../src/os/os.h fstd_types.h
+      ../../src/os/os.h:
+      fstd_types.h:
+    RULES
+    expect(extract(rules).map(&:filepath)).to contain_exactly('../../src/os/os.h', 'fstd_types.h')
+  end
+
+  it 'deduplicates a dependency that appears in more than one phony rule' do
+    rules = <<~RULES
+      a.o: a.c shared.h
+      shared.h:
+      shared.h:
+    RULES
+    expect(extract(rules).map(&:filename)).to eq(['shared.h'])
+  end
+
+  it 'ignores GCC diagnostic lines interleaved with the phony rules' do
+    rules = <<~RULES
+      os.o: os.c os.h
+      os.h:
+      os.h:73:20: error: no include path in which to search for stdint.h
+         73 | #include <stdint.h>
+            |                    ^
+    RULES
+    expect(extract(rules).map(&:filename)).to eq(['os.h'])
+  end
+
+  it 'ignores a bare dependency filename that has no extension' do
+    # INCLUDE_MATCHER requires a `.<ext>` -- an extensionless phony rule is skipped.
+    rules = <<~RULES
+      m.o: m.c helper.h Makefile
+      helper.h:
+      Makefile:
+    RULES
+    expect(extract(rules).map(&:filename)).to eq(['helper.h'])
+  end
+end