ceedling 1.1.3 → 1.1.4

data/spec/units/generators/generator_test_results_backtrace_spec.rb

@@ -7,7 +7,9 @@
 
 require 'spec_helper'
 require 'ceedling/generators/generator_test_results_backtrace'
+require 'ceedling/generators/generator_helper'
 require 'ceedling/constants'
+require 'ceedling/exceptions'
 
 # ── Representative gdb output constants ──────────────────────────────────────
 
@@ -125,9 +127,9 @@ SIMPLE_ASSERT_CRASH_OUTPUT =
   "test_lib.out: src/lib.c:5: asserting: Assertion `0' failed.\n" \
   "Aborted (core dumped)\n"
 
-SIMPLE_PASS_OUTPUT   = "test_lib.c:3:test_empty:PASS\n"
-SIMPLE_FAIL_OUTPUT   = "test_lib.c:8:test_bad:FAIL: Expected 1 Was 2\n"
-SIMPLE_IGNORE_OUTPUT = "test_lib.c:12:test_skip:IGNORE\n"
+SIMPLE_PASS_OUTPUT   = "test_lib.c:3:test_empty:PASS\n---------\n1 Tests 0 Failures 0 Ignored\nOK\n"
+SIMPLE_FAIL_OUTPUT   = "test_lib.c:8:test_bad:FAIL: Expected 1 Was 2\n---------\n1 Tests 1 Failures 0 Ignored\nFAIL\n"
+SIMPLE_IGNORE_OUTPUT = "test_lib.c:12:test_skip:IGNORE\n---------\n1 Tests 0 Failures 1 Ignored\nOK\n"
 
 
 describe GeneratorTestResultsBacktrace do
@@ -140,16 +142,28 @@ describe GeneratorTestResultsBacktrace do
     @generator_test_results  = instance_double('GeneratorTestResults')
     @file_path_utils         = instance_double('FilePathUtils')
     @file_wrapper            = instance_double('FileWrapper')
+    @loginator               = double('loginator').as_null_object
+    # A real GeneratorHelper, not a double -- these tests exercise the actual crash
+    # detection logic a retry's status is checked against, not a stubbed stand-in for it.
+    @generator_helper        = GeneratorHelper.new({ :loginator => @loginator })
 
     @backtrace = described_class.new({
       :configurator           => @configurator,
       :tool_executor          => @tool_executor,
       :generator_test_results => @generator_test_results,
+      :generator_helper       => @generator_helper,
       :file_path_utils        => @file_path_utils,
-      :file_wrapper           => @file_wrapper
+      :file_wrapper           => @file_wrapper,
+      :loginator              => @loginator
     })
     @backtrace.setup()
 
+    # A healthy retry sub-process status -- the common case for most stubs below. Crash
+    # scenarios that already resolve via a missing result-line match (the pre-existing
+    # "unresolved" path) don't depend on this value at all; it's included on every stub
+    # anyway so `crash_result[:status]` is never unexpectedly missing.
+    @ok_status = double('status', signaled?: false, success?: true, exitstatus: 0, termsig: nil)
+
     # Standard stubs used by most tests
     allow(@tool_executor).to receive(:build_command_line).and_return({ options: {} })
     allow(@file_path_utils).to receive(:form_test_gdb_log) do |test, context:, name:|
@@ -173,37 +187,113 @@ describe GeneratorTestResultsBacktrace do
       allow(@configurator).to receive(:tools_test_backtrace_gdb).and_return({})
     end
 
+    # Companion helper: a genuinely-crashing group paired alongside the group under
+    # test, matching realistic multi-test-case usage -- do_gdb only ever runs because
+    # the main run already crashed, so an isolated group with nothing but a clean match
+    # is indistinguishable from the #1198 bug pattern (every retry legitimately clean,
+    # contradicting the crash that triggered this method) and correctly falls back on
+    # its own, tested separately below.
+    let(:companion_case) { { test: 'test_crashes_elsewhere', symbol: 'test_crashes_elsewhere', line_number: 20 } }
+
     it 'handles a PASS test case and does not write a log' do
-      allow(@tool_executor).to receive(:exec)
-        .and_return({ output: "test_lib.c:9:test_asserting:PASS\n", time: 0.1, exit_code: 0 })
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status },
+        { output: "test_lib.c:9:test_asserting:PASS\n---------\n1 Tests 0 Failures 0 Ignored\nOK\n",
+          time: 0.1, exit_code: 0, stderr: '', status: @ok_status }
+      )
 
-      expect(@file_wrapper).not_to receive(:write)
+      expect(@file_wrapper).to receive(:write).once.with(%r{test_crashes_elsewhere}, anything, anything)
 
-      result = @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: :test )
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
 
-      expect(result[:exit_code]).to eq(0)
+      @backtrace.do_gdb( filename, executable, shell_result, [companion_case] + test_cases, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:9:test_asserting:PASS')
     end
 
     it 'handles an IGNORE test case and does not write a log' do
-      allow(@tool_executor).to receive(:exec)
-        .and_return({ output: "test_lib.c:9:test_asserting:IGNORE\n", time: 0.1, exit_code: 0 })
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status },
+        { output: "test_lib.c:9:test_asserting:IGNORE\n---------\n1 Tests 0 Failures 1 Ignored\nOK\n",
+          time: 0.1, exit_code: 0, stderr: '', status: @ok_status }
+      )
 
-      expect(@file_wrapper).not_to receive(:write)
+      expect(@file_wrapper).to receive(:write).once.with(%r{test_crashes_elsewhere}, anything, anything)
 
-      result = @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: :test )
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
 
-      expect(result[:exit_code]).to eq(0)
+      @backtrace.do_gdb( filename, executable, shell_result, [companion_case] + test_cases, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:9:test_asserting:IGNORE')
     end
 
     it 'handles a FAIL test case and does not write a log' do
-      allow(@tool_executor).to receive(:exec)
-        .and_return({ output: "test_lib.c:9:test_asserting:FAIL: Expected 1 Was 2\n", time: 0.1, exit_code: 1 })
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status },
+        { output: "test_lib.c:9:test_asserting:FAIL: Expected 1 Was 2\n---------\n1 Tests 1 Failures 0 Ignored\nFAIL\n",
+          time: 0.1, exit_code: 1, stderr: '', status: @ok_status }
+      )
 
-      expect(@file_wrapper).not_to receive(:write)
+      expect(@file_wrapper).to receive(:write).once.with(%r{test_crashes_elsewhere}, anything, anything)
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      @backtrace.do_gdb( filename, executable, shell_result, [companion_case] + test_cases, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:9:test_asserting:FAIL: Expected 1 Was 2')
+    end
+
+    it "does not trust a matched PASS line when the retry's own real status contradicts it" do
+      # Regression test for issue #1198: a diagnostic retry can print a clean Unity
+      # result line while its own real process outcome says otherwise.
+      bad_status = double('status', signaled?: false, success?: false, exitstatus: 1, termsig: nil)
+
+      allow(@tool_executor).to receive(:exec).and_return({
+        output: "test_lib.c:9:test_asserting:PASS\n---------\n1 Tests 0 Failures 0 Ignored\nOK\n",
+        time: 0.1, exit_code: 0, stderr: '', status: bad_status
+      })
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
 
       result = @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: :test )
 
       expect(result[:exit_code]).to eq(1)
+      expect(expected_output_lines.first).to include(':FAIL:')
+    end
+
+    it 'falls back to a whole-file crash failure when no retry ever reproduces the crash the main run detected' do
+      # Regression test for issue #1198: every retry can legitimately pass in its own,
+      # differently-configured environment even though the main run genuinely crashed.
+      # An all-clean diagnostic must not be allowed to overrule that.
+      allow(@tool_executor).to receive(:exec).and_return({
+        output: "test_lib.c:9:test_asserting:PASS\n---------\n1 Tests 0 Failures 0 Ignored\nOK\n",
+        time: 0.1, exit_code: 0, stderr: '', status: @ok_status
+      })
+
+      fallback_result = { output: 'crash-failure-output', exit_code: 1 }
+      expect(@generator_test_results).to receive(:create_crash_failure)
+        .with(filename, shell_result, test_cases)
+        .and_return(fallback_result)
+
+      result = @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: :test )
+
+      expect(result).to eq(fallback_result)
     end
 
     it 'handles a SIGSEGV crash — writes log, includes signal label, backtick source line, and log path' do
@@ -211,7 +301,7 @@ describe GeneratorTestResultsBacktrace do
       filename_sigsegv   = 'TestUsartModel.c'
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: GDB_SIGSEGV_OUTPUT, time: 0.5, exit_code: 139 })
+        .and_return({ output: GDB_SIGSEGV_OUTPUT, time: 0.5, exit_code: 139, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -241,7 +331,7 @@ describe GeneratorTestResultsBacktrace do
       filename_param = 'test_module_d.c'
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: GDB_SIGSEGV_PARAM_OUTPUT, time: 0.5, exit_code: 139 })
+        .and_return({ output: GDB_SIGSEGV_PARAM_OUTPUT, time: 0.5, exit_code: 139, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -267,7 +357,7 @@ describe GeneratorTestResultsBacktrace do
       test_cases_assert = [{ test: 'test_asserting', symbol: 'test_asserting', line_number: 8 }]
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: GDB_SIGABRT_ASSERT_OUTPUT, time: 0.3, exit_code: 134 })
+        .and_return({ output: GDB_SIGABRT_ASSERT_OUTPUT, time: 0.3, exit_code: 134, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -288,7 +378,7 @@ describe GeneratorTestResultsBacktrace do
 
     it 'handles a crash with no identifiable signal — fallback message, log path without "log: " prefix' do
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1 })
+        .and_return({ output: GDB_NO_SIGNAL_OUTPUT, time: 0.1, exit_code: 1, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -317,42 +407,115 @@ describe GeneratorTestResultsBacktrace do
       allow(@configurator).to receive(:tools_test_fixture_simple_backtrace).and_return({})
     end
 
+    # Each of the three cases below is paired with a companion group that genuinely
+    # crashes -- a realistic multi-test-case file, where the group under test is only
+    # one of several. Without a companion, an isolated group with nothing but a clean
+    # match is indistinguishable from the #1198 bug pattern (every retry legitimately
+    # clean, contradicting the crash do_simple only ever runs because of) and correctly
+    # triggers the whole-file fallback tested below in its own right.
+
     it 'handles a PASS test case' do
-      allow(@tool_executor).to receive(:exec)
-        .and_return({ output: SIMPLE_PASS_OUTPUT, time: 0.05, exit_code: 0 })
+      test_cases_multi = [{ test: 'test_crashes_elsewhere', line_number: 20 }] + test_cases
 
-      result = @backtrace.do_simple( filename, executable, shell_result, test_cases, context: :test )
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status },
+        { output: SIMPLE_PASS_OUTPUT, time: 0.05, exit_code: 0, stderr: '', status: @ok_status }
+      )
 
-      expect(result[:exit_code]).to eq(0)
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      @backtrace.do_simple( filename, executable, shell_result, test_cases_multi, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:3:test_empty:PASS')
     end
 
     it 'handles a FAIL test case with a message' do
-      test_cases_fail = [{ test: 'test_bad', line_number: 8 }]
+      test_cases_fail = [{ test: 'test_crashes_elsewhere', line_number: 20 }, { test: 'test_bad', line_number: 8 }]
 
-      allow(@tool_executor).to receive(:exec)
-        .and_return({ output: SIMPLE_FAIL_OUTPUT, time: 0.05, exit_code: 1 })
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status },
+        { output: SIMPLE_FAIL_OUTPUT, time: 0.05, exit_code: 1, stderr: '', status: @ok_status }
+      )
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
 
-      result = @backtrace.do_simple( filename, executable, shell_result, test_cases_fail, context: :test )
+      @backtrace.do_simple( filename, executable, shell_result, test_cases_fail, context: :test )
 
-      expect(result[:exit_code]).to eq(1)
+      expect(expected_output_lines).to include('test_lib.c:8:test_bad:FAIL: Expected 1 Was 2')
     end
 
     it 'handles an IGNORE test case' do
-      test_cases_ignore = [{ test: 'test_skip', line_number: 12 }]
+      test_cases_ignore = [{ test: 'test_crashes_elsewhere', line_number: 20 }, { test: 'test_skip', line_number: 12 }]
+
+      allow(@tool_executor).to receive(:exec).and_return(
+        { output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status },
+        { output: SIMPLE_IGNORE_OUTPUT, time: 0.02, exit_code: 0, stderr: '', status: @ok_status }
+      )
+
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      @backtrace.do_simple( filename, executable, shell_result, test_cases_ignore, context: :test )
+
+      expect(expected_output_lines).to include('test_lib.c:12:test_skip:IGNORE')
+    end
+
+    it "does not trust a matched PASS line when the retry's own real status contradicts it" do
+      # Regression test for issue #1198: a diagnostic retry can print a clean Unity
+      # result line while its own real process outcome says otherwise.
+      bad_status = double('status', signaled?: false, success?: false, exitstatus: 1, termsig: nil)
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: SIMPLE_IGNORE_OUTPUT, time: 0.02, exit_code: 0 })
+        .and_return({ output: SIMPLE_PASS_OUTPUT, time: 0.05, exit_code: 0, stderr: '', status: bad_status })
 
-      result = @backtrace.do_simple( filename, executable, shell_result, test_cases_ignore, context: :test )
+      expected_output_lines = []
+      allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
+        expected_output_lines = kwargs[:output]
+        'regenerated'
+      end
+
+      result = @backtrace.do_simple( filename, executable, shell_result, test_cases, context: :test )
+
+      expect(result[:exit_code]).to eq(1)
+      expect(expected_output_lines.first).to include(':FAIL:')
+    end
+
+    it 'falls back to a whole-file crash failure when no retry ever reproduces the crash the main run detected' do
+      # Regression test for issue #1198: the exact reported scenario -- a custom
+      # :test_fixture wrapper enables sanitizer halt-on-error and the main run crashes,
+      # but the unrelated, independently-configured test_fixture_simple_backtrace tool
+      # runs the same executable directly, without the wrapper, and it legitimately
+      # passes. Every retry can be entirely clean and still must not overrule a crash
+      # Ceedling already established.
+      allow(@tool_executor).to receive(:exec)
+        .and_return({ output: SIMPLE_PASS_OUTPUT, time: 0.05, exit_code: 0, stderr: '', status: @ok_status })
+
+      fallback_result = { output: 'crash-failure-output', exit_code: 1 }
+      expect(@generator_test_results).to receive(:create_crash_failure)
+        .with(filename, shell_result, test_cases)
+        .and_return(fallback_result)
+
+      result = @backtrace.do_simple( filename, executable, shell_result, test_cases, context: :test )
 
-      expect(result[:exit_code]).to eq(0)
+      expect(result).to eq(fallback_result)
     end
 
     it 'handles a crash and includes extra executable output in the failure message' do
       test_cases_crash = [{ test: 'test_asserting', line_number: 8 }]
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134 })
+        .and_return({ output: SIMPLE_ASSERT_CRASH_OUTPUT, time: 0.1, exit_code: 134, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -372,7 +535,7 @@ describe GeneratorTestResultsBacktrace do
       test_cases_crash = [{ test: 'test_asserting', line_number: 8 }]
 
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: "\n\n\n", time: 0.1, exit_code: 134 })
+        .and_return({ output: "\n\n\n", time: 0.1, exit_code: 134, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|
@@ -515,7 +678,7 @@ describe GeneratorTestResultsBacktrace do
 
     it 'uses assertion label and metadata line number when no crash location frame is found' do
       allow(@tool_executor).to receive(:exec)
-        .and_return({ output: GDB_WINDOWS_ASSERT_BRIEF_OUTPUT, time: 0.1, exit_code: 3 })
+        .and_return({ output: GDB_WINDOWS_ASSERT_BRIEF_OUTPUT, time: 0.1, exit_code: 3, stderr: '', status: @ok_status })
 
       expected_output_lines = []
       allow(@generator_test_results).to receive(:regenerate_test_executable_stdout) do |**kwargs|

data/spec/units/includes/include_spec.rb

@@ -30,9 +30,9 @@ describe UserInclude do
       expect(include_obj).to eq('header.h')
     end
 
-    it "creates a UserInclude with a path and used path in string expansion" do
-      include_obj = UserInclude.new("path/to/header.h", use_path: true)
-      
+    it "creates a UserInclude with an include_path override used in string expansion" do
+      include_obj = UserInclude.new("path/to/header.h", include_path: "path/to/header.h")
+
       expect(include_obj.filename).to eq("header.h")
       expect(include_obj.filepath).to eq("path/to/header.h")
       expect("#{include_obj}").to eq('#include "path/to/header.h"')
@@ -110,14 +110,26 @@ describe SystemInclude do
       expect(include_obj).to eq('header.h')
     end
 
-    it "creates a SystemInclude with a path and used path in string expansion" do
-      include_obj = SystemInclude.new("path/to/header.h", use_path: true)
-      
+    it "creates a SystemInclude with an include_path override used in string expansion" do
+      include_obj = SystemInclude.new("path/to/header.h", include_path: "path/to/header.h")
+
       expect(include_obj.filename).to eq("header.h")
       expect(include_obj.filepath).to eq("path/to/header.h")
       expect("#{include_obj}").to eq('#include <path/to/header.h>')
       expect(include_obj).to eq('path/to/header.h')
     end
+
+    it "renders include_path instead of the bare filename, while filepath/filename keep the resolved identity" do
+      include_obj = SystemInclude.new(
+        "/usr/include/x86_64-linux-gnu/sys/stat.h", include_path: "sys/stat.h"
+      )
+
+      expect(include_obj.filepath).to eq("/usr/include/x86_64-linux-gnu/sys/stat.h")
+      expect(include_obj.filename).to eq("stat.h")
+      expect(include_obj.include_path).to eq("sys/stat.h")
+      expect("#{include_obj}").to eq('#include <sys/stat.h>')
+      expect(include_obj).to eq('sys/stat.h')
+    end
   end
 
   describe "Graceful handling of input" do
@@ -189,9 +201,9 @@ describe "Include equality" do
     end
 
     it "compares not equal to another UserInclude with same filename but different paths" do
-      include1 = UserInclude.new("path1/header.h", use_path: true)
-      include2 = UserInclude.new("path2/header.h", use_path: true)
-      
+      include1 = UserInclude.new("path1/header.h", include_path: "path1/header.h")
+      include2 = UserInclude.new("path2/header.h", include_path: "path2/header.h")
+
       expect(include1).not_to eq(include2)
       expect(include2).not_to eq(include1)
     end
@@ -266,9 +278,9 @@ describe "Include equality" do
     end
 
     it "compares not equal to another SystemInclude with same filename but different paths" do
-      include1 = SystemInclude.new("sys/stdio.h", use_path: true)
-      include2 = SystemInclude.new("other/stdio.h", use_path: true)
-      
+      include1 = SystemInclude.new("sys/stdio.h", include_path: "sys/stdio.h")
+      include2 = SystemInclude.new("other/stdio.h", include_path: "other/stdio.h")
+
       expect(include1).not_to eq(include2)
       expect(include2).not_to eq(include1)
     end
@@ -342,9 +354,9 @@ describe "Include equality" do
     end
 
     it "compares not equal to another MockInclude with same filename but different paths" do
-      include1 = MockInclude.new("mocks/mock_module.h", use_path: true)
-      include2 = MockInclude.new("test/mocks/mock_module.h", use_path: true)
-      
+      include1 = MockInclude.new("mocks/mock_module.h", include_path: "mocks/mock_module.h")
+      include2 = MockInclude.new("test/mocks/mock_module.h", include_path: "test/mocks/mock_module.h")
+
       expect(include1).not_to eq(include2)
       expect(include2).not_to eq(include1)
     end
@@ -547,9 +559,9 @@ describe "Include string coercion (to_str)" do
       expect(include_obj.to_str).to eq("header.h")
     end
 
-    it "returns the full filepath when constructed with use_path: true" do
-      include_obj = UserInclude.new("sub/dir/header.h", use_path: true)
-      # to_str always returns @filename (the basename) regardless of use_path
+    it "returns the basename even when constructed with an include_path override" do
+      include_obj = UserInclude.new("sub/dir/header.h", include_path: "sub/dir/header.h")
+      # to_str always returns @filename (the basename) regardless of include_path
       expect(include_obj.to_str).to eq("header.h")
     end
   end

data/spec/units/includes/includes_spec.rb

@@ -111,20 +111,38 @@ describe "Includes serialization" do
       expect(restored.map(&:filename)).to eq(["first.h", "second.h", "third.h", "fourth.h"])
     end
 
-    it "handles includes with paths during serialization" do
+    it "handles includes with an include_path override during serialization" do
       original = [
-        UserInclude.new("path/to/header.h", use_path: true),
-        SystemInclude.new("sys/stdio.h", use_path: true),
-        MockInclude.new("mocks/mock_module.h", use_path: true)
+        UserInclude.new("path/to/header.h", include_path: "path/to/header.h"),
+        SystemInclude.new("sys/stdio.h", include_path: "sys/stdio.h"),
+        MockInclude.new("mocks/mock_module.h")
       ]
-      
+
       hashes = Includes.to_hashes(original)
       restored = Includes.from_hashes(hashes)
-      
+
       expect(restored.length).to eq(3)
       expect(restored[0].filepath).to eq("path/to/header.h")
       expect(restored[1].filepath).to eq("sys/stdio.h")
       expect(restored[2].filepath).to eq("mocks/mock_module.h")
+      # `include_path` must itself round-trip, not merely `filepath` -- otherwise a cached
+      # build silently reverts to filename-only rendering on its next, cache-hit run.
+      expect("#{restored[0]}").to eq('#include "path/to/header.h"')
+      expect("#{restored[1]}").to eq('#include <sys/stdio.h>')
+    end
+
+    it "round-trips include_path, and has it take rendering precedence over filepath/filename" do
+      original = [
+        SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h", include_path: "sys/stat.h")
+      ]
+
+      hashes = Includes.to_hashes(original)
+      restored = Includes.from_hashes(hashes)
+
+      expect(restored.length).to eq(1)
+      expect(restored[0].filepath).to eq("/usr/include/x86_64-linux-gnu/sys/stat.h")
+      expect(restored[0].include_path).to eq("sys/stat.h")
+      expect("#{restored[0]}").to eq("#include <sys/stat.h>")
     end
 
     it "handles empty array" do
@@ -1054,16 +1072,88 @@ describe "Includes reconciliation" do
         Include.new("subdir/header.h"),
         Include.new("sys/types.h")
       ]
-      
+
       user = [UserInclude.new("header.h")]
       system = [SystemInclude.new("types.h")]
-      
+
       result = Includes.reconcile(bare: bare, user: user, system: system)
-      
+
       # Should match by filename only
       expect(result.length).to eq(2)
       expect(result[0].filename).to eq("types.h")
       expect(result[1].filename).to eq("header.h")
     end
+
+    it "preserves a system include directive's original directory components instead of collapsing to its bare filename" do
+      bare = [Include.new("sys/stat.h")]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect(result[0]).to be_a(SystemInclude)
+      expect(result[0].filepath).to eq("/usr/include/x86_64-linux-gnu/sys/stat.h")
+      expect("#{result[0]}").to eq("#include <sys/stat.h>")
+      expect(Includes.from_hashes(Includes.to_hashes(result)).map(&:to_s)).to eq(["#include <sys/stat.h>"])
+    end
+
+    it "prefers the more specific bare entry when a system header's basename collides with an unrelated bare entry" do
+      # A project's own quoted `#include "stat.h"` sitting alongside a system
+      # `#include <sys/stat.h>` in the same file: both reach `bare` as plain, untyped
+      # Include objects, and the short entry trivially "corresponds" to any longer
+      # resolved path ending in the same filename. The longer, genuinely-corresponding
+      # entry must still win, regardless of which one happens to appear first in `bare`.
+      bare = [
+        Include.new("stat.h"),
+        Include.new("sys/stat.h")
+      ]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/sys/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect("#{result[0]}").to eq("#include <sys/stat.h>")
+    end
+
+    it "falls back to a same-filename bare entry when nothing corresponds by path" do
+      # The compiler's real search-path structure can diverge from a directive's own
+      # literal spelling (a symlinked or vendored include root, for instance), so a
+      # resolved system path may not share any trailing segment with its bare entry
+      # beyond the filename itself. Rendering the bare entry's own spelling is still
+      # strictly better than collapsing to the bare filename alone.
+      bare = [Include.new("compat/stat.h")]
+      user = []
+      system = [SystemInclude.new("/usr/include/x86_64-linux-gnu/bits/stat.h")]
+
+      result = Includes.reconcile(bare: bare, user: user, system: system)
+
+      expect(result.length).to eq(1)
+      expect("#{result[0]}").to eq("#include <compat/stat.h>")
+    end
+
+    it "does not hard-error over two same-named system headers, a normal toolchain wrapper-chain pattern rather than a project-file conflict" do
+      # e.g. a compiler-provided stdint.h #include_next-ing its libc counterpart --
+      # both real, both legitimately entered, both sharing a basename, neither a
+      # project file whose identity is actually in question.
+      bare = [Include.new("stdint.h")]
+
+      user = []
+      system = [
+        SystemInclude.new("/usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h"),
+        SystemInclude.new("/usr/include/stdint.h")
+      ]
+
+      result = nil
+      expect {
+        result = Includes.reconcile(bare: bare, user: user, system: system)
+      }.not_to raise_error
+
+      expect(result.length).to eq(2)
+      expect(result.map(&:filepath)).to include(
+        "/usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h", "/usr/include/stdint.h"
+      )
+    end
   end
-end    
+end