ceedling 1.1.1 → 1.1.2

data/spec/system/support/gcov_common_test_cases.rb

@@ -18,8 +18,8 @@ module GcovCommonTestCases
         FileUtils.cp test_asset_path("example_file.c"), 'src/'
         FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(0) # Since test cases either pass or are ignored, Ceedling exits with success
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0) # Since test cases either pass or are ignored, Ceedling exits with success
         expect(output).to match(/TESTED:\s+\d/)
         expect(output).to match(/PASSED:\s+\d/)
         expect(output).to match(/FAILED:\s+\d/)
@@ -36,8 +36,8 @@ module GcovCommonTestCases
         FileUtils.cp test_asset_path("example_file.c"), 'src/'
         FileUtils.cp test_asset_path("test_example_file.c"), 'test/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(1) # Unit test failures => Ceedling exit code 1
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(1) # Unit test failures => Ceedling exit code 1
         expect(output).to match(/TESTED:\s+\d/)
         expect(output).to match(/PASSED:\s+\d/)
         expect(output).to match(/FAILED:\s+\d/)
@@ -122,8 +122,8 @@ module GcovCommonTestCases
         FileUtils.cp test_asset_path("example_file.c"), 'src/'
         FileUtils.cp test_asset_path("test_example_file_boom.c"), 'test/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(1) # Since a test explodes, Ceedling exits with error
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(1) # Since a test explodes, Ceedling exits with error
         expect(output).to match(/(?:ERROR: Ceedling Failed)|(?:Ceedling could not complete operations because of errors)/)
       end
     end
@@ -133,8 +133,8 @@ module GcovCommonTestCases
     @c.with_context do
       Dir.chdir @proj_name do
         prep_project_yml_for_coverage
-        output = `bundle exec ruby -S ceedling help 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_appcmd_exec("help")
+        expect(@c.last_exit_status).to eq(0)
         expect(output).to match(/ceedling gcov:\*/i)
         expect(output).to match(/ceedling gcov:all/i)
       end
@@ -149,7 +149,7 @@ module GcovCommonTestCases
         FileUtils.cp test_asset_path("example_file.c"), 'src/'
         FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
+        output = @c.ceedling_build_exec("gcov:all")
         if @gcov_reports.include? :gcovr
           expect(output).to match(/Generating HTML coverage report in 'build\/artifacts\/gcov\/gcovr\/'\.\.\./)
           expect(File.exist?('build/artifacts/gcov/gcovr/GcovCoverageResults.html')).to eq true
@@ -170,8 +170,8 @@ module GcovCommonTestCases
         FileUtils.cp test_asset_path("example_file_with_stdio.c"), 'src/'
         FileUtils.cp test_asset_path("test_example_file_with_stdio.c"), 'test/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0)
         # Console summary must report coverage for the source file, not a warning.
         # When <stdio.h> is included, gcov may list a system header (e.g. _stdio.h)
         # as the first File entry — the fix ensures the correct source is found.
@@ -194,8 +194,8 @@ module GcovCommonTestCases
 
         @c.merge_project_yml_for_test({ :project => { :use_partials => true } })
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0)
         # Coverage must be reported for the Partial (gcov references the original
         # module via #line remapping); no spurious "Found no coverage results" warning.
         expect(output).to match(/Lines executed:/)
@@ -216,18 +216,7 @@ module GcovCommonTestCases
         # coverage entries: Ceedling builds one executable per test file, and both
         # link against example_file.c, producing two sets of .gcda coverage data
         # for the same functions.
-        File.write('test/test_example_file_2.c', <<~C)
-          #include "unity.h"
-          #include "example_file.h"
-
-          void setUp(void) {}
-          void tearDown(void) {}
-
-          void test_difference_between_two_numbers(void)
-          {
-            TEST_ASSERT_EQUAL_INT(0, difference_between_numbers(1, 1));
-          }
-        C
+        FileUtils.cp test_asset_path("test_example_file_2.c"), 'test/'
 
         # 'strict' causes gcovr to exit non-zero when the same function appears in
         # multiple test executables' coverage data. Ceedling's default is
@@ -246,11 +235,11 @@ module GcovCommonTestCases
           }
         })
 
-        output = `bundle exec ruby -S ceedling gcov:all --verbosity=obnoxious 2>&1`
+        output = @c.ceedling_build_exec("gcov:all --verbosity=obnoxious")
         if @gcov_reports.include? :gcovr
           # Config file honored (fix applied): strict mode exits non-zero on duplicate functions.
           # Config file overridden by Ceedling CLI (bug): merge-use-line-max exits 0.
-          expect($?.exitstatus).not_to eq(0)
+          expect(@c.last_exit_status).not_to eq(0)
 
           # No `--exclude` should appear on the gcovr command line when a config file is in use.
           expect(output).not_to match(/--exclude/)
@@ -269,8 +258,8 @@ module GcovCommonTestCases
 
         @c.merge_project_yml_for_test({:project => { :use_backtrace => :gdb }})
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(1) # Ceedling should exit with error because of failed test due to crash
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(1) # Ceedling should exit with error because of failed test due to crash
         expect(output).to match(/crashed/i)
         expect(output).to match(/Unit test failures/)
         expect(File.exist?('./build/gcov/results/test_example_file_crash_sigsegv.fail'))
@@ -303,8 +292,8 @@ module GcovCommonTestCases
 
         @c.merge_project_yml_for_test({:project => { :use_backtrace => :gdb }})
 
-        output = `bundle exec ruby -S ceedling gcov:all --exclude_test_case=test_add_numbers_adds_numbers 2>&1`
-        expect($?.exitstatus).to match(1) # Ceedling should exit with error because of failed test due to crash
+        output = @c.ceedling_build_exec("gcov:all --exclude_test_case=test_add_numbers_adds_numbers")
+        expect(@c.last_exit_status).to eq(1) # Ceedling should exit with error because of failed test due to crash
         expect(output).to match(/Test Case Crashed/i)
         expect(output).to match(/Unit test failures/)
         expect(File.exist?('./build/gcov/results/test_example_file_crash_sigsegv.fail'))
@@ -345,8 +334,8 @@ module GcovCommonTestCases
         updated_test_file.insert(updated_test_file.length(), add_test_case)
         File.write('test/test_example_file_crash_sigsegv.c', updated_test_file.join("\n"), mode: 'w')
 
-        output = `bundle exec ruby -S ceedling gcov:all --exclude_test_case=test_add_numbers_will_fail 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:all --exclude_test_case=test_add_numbers_will_fail")
+        expect(@c.last_exit_status).to eq(0)
         expect(File.exist?('./build/gcov/results/test_example_file_crash_sigsegv.pass'))
         expect(output).to match(/TESTED:\s+2/)
         expect(output).to match(/PASSED:\s+2/)
@@ -377,8 +366,8 @@ module GcovCommonTestCases
         # Untested — no test references this source file.
         FileUtils.cp test_asset_path("uncovered_example_file.c"), 'src/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0)
         expect(output).not_to match(/Untested Source Files/)
         expect(output).not_to match(/Processing Untested Sources/)
         expect(output).not_to match(/uncovered_example_file/)
@@ -397,8 +386,8 @@ module GcovCommonTestCases
         # Untested — no test references this source file.
         FileUtils.cp test_asset_path("uncovered_example_file.c"), 'src/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to eq(0)
         # Immediate warning-level filepath listing (no compilation attempted).
         expect(output).to match(/Untested.+not.+coverage report/)
         expect(output).to match(/uncovered_example_file\.c/)
@@ -421,13 +410,10 @@ module GcovCommonTestCases
 
         # Untested source with a syntax error — fails to compile regardless of
         # any :defines/:flags, deliberately triggering the guidance notice.
-        File.write('src/broken_uncovered_file.c', <<~C)
-          int broken_uncovered_function(int a, int b) {
-            return a + b // Missing semicolon and closing brace: guaranteed compile error.
-        C
+        FileUtils.cp test_asset_path("broken_uncovered_file.c"), 'src/'
 
-        output = `bundle exec ruby -S ceedling gcov:all 2>&1`
-        expect($?.exitstatus).not_to eq(0) # Fail-fast: compile failure fails the build
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).not_to eq(0) # Fail-fast: compile failure fails the build
         expect(output).to match(/Compiling.+with coverage failed/)
         expect(output).to match(/:untested_sources.*:compile/)
         # Avoid unicode character matching in log matching, since some shells may not support them.
@@ -450,8 +436,8 @@ module GcovCommonTestCases
 
         # Run the standalone task directly — no prior `gcov:all` in this invocation,
         # so no test fixture is ever built or executed.
-        output = `bundle exec ruby -S ceedling gcov:untested_sources 2>&1`
-        expect($?.exitstatus).to match(0)
+        output = @c.ceedling_build_exec("gcov:untested_sources")
+        expect(@c.last_exit_status).to eq(0)
         expect(output).not_to match(/TESTED:\s+\d/) # No test build/run occurred
         expect(File.exist?('build/gcov/out/uncovered_example_file.o')).to eq true
       end

data/spec/system/support/gcov_partials_test_cases.rb

@@ -0,0 +1,116 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rexml/document'
+require_relative 'gcov_helpers'
+
+module GcovPartialsTestCases
+  include GcovHelpers
+
+  # Runs `ceedling gcov:all` with Partials + Cobertura XML reporting enabled, then
+  # returns { line_number => hits } for `source_relpath` (e.g. 'src/blanks.c').
+  def partials_cobertura_hits_by_line(source_relpath)
+    @c.merge_project_yml_for_test({
+      :project => { :use_partials => true },
+      :gcov    => { :reports => ['Cobertura'] }
+    })
+
+    output = @c.ceedling_build_exec("gcov:all")
+    expect(@c.last_exit_status).to eq(0)
+
+    cobertura_path = File.join('build', 'artifacts', 'gcov', 'gcovr', 'GcovCoverageCobertura.xml')
+    doc = REXML::Document.new(File.read(cobertura_path))
+
+    doc.elements.to_a("//class[@filename='#{source_relpath}']/lines/line").each_with_object({}) do |el, h|
+      h[el.attributes['number'].to_i] = el.attributes['hits'].to_i
+    end
+  end
+
+  def gcov_partials_coverage_blank_lines_in_function_body
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+
+        # Multiple consecutive blank lines inside a function body -- the same
+        # shape a stripped multi-line comment leaves behind -- sit between the
+        # opening brace and the one executed statement. Each function in a
+        # generated Partial gets exactly one #line directive, at its own first
+        # line; every line after that is trusted to match the original source
+        # 1:1. If any lines partway through the body go missing during
+        # reconstruction, gcov's line attribution for everything after that
+        # point in the function shifts up by the deficit.
+        asset_base = test_asset_path("tests_with_partials_coverage")
+        FileUtils.cp "#{asset_base}/src/blanks.h",       'src/'
+        FileUtils.cp "#{asset_base}/src/blanks.c",       'src/'
+        FileUtils.cp "#{asset_base}/test/test_blanks.c", 'test/'
+
+        hits = partials_cobertura_hits_by_line('src/blanks.c')
+
+        # `return;` is on source line 5 -- it must show as hit.
+        expect(hits[5]).to be > 0
+        # The blank lines (3-4) must not appear as executable/hit lines at all.
+        expect(hits[3]).to be_nil
+        expect(hits[4]).to be_nil
+      end
+    end
+  end
+
+  def gcov_partials_coverage_decorators_on_own_lines
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+
+        # `static` and `inline` each occupy their own line ahead of the return
+        # type. Partials strips both keywords from the front of the extracted
+        # function text (per the docs, functions are stripped of `static` and
+        # `inline`) and must bump the emitted #line directive forward by
+        # exactly the number of lines that stripping removed -- otherwise the
+        # whole body, including the blank line below, reports coverage against
+        # the wrong original source lines.
+        asset_base = test_asset_path("tests_with_partials_coverage")
+        FileUtils.cp "#{asset_base}/src/decorators.h",       'src/'
+        FileUtils.cp "#{asset_base}/src/decorators.c",       'src/'
+        FileUtils.cp "#{asset_base}/test/test_decorators.c", 'test/'
+
+        hits = partials_cobertura_hits_by_line('src/decorators.c')
+
+        # `return;` is on source line 7 -- it must show as hit.
+        expect(hits[7]).to be > 0
+        # The blank line (6) must not appear as an executable/hit line.
+        expect(hits[6]).to be_nil
+      end
+    end
+  end
+
+  def gcov_partials_coverage_function_scope_static_promotion
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+
+        # A function-scope `static` variable is replaced with a no-op and
+        # promoted to module scope so the Partial's testable copy of the
+        # function keeps the original's persistence semantics (per the docs'
+        # Partials creation steps). Confirms that substitution doesn't shift
+        # the lines after it out of alignment with their original source line
+        # numbers.
+        asset_base = test_asset_path("tests_with_partials_coverage")
+        FileUtils.cp "#{asset_base}/src/counter.h",       'src/'
+        FileUtils.cp "#{asset_base}/src/counter.c",       'src/'
+        FileUtils.cp "#{asset_base}/test/test_counter.c", 'test/'
+
+        hits = partials_cobertura_hits_by_line('src/counter.c')
+
+        # `count++;` (line 5) and `return count;` (line 7) must both show as
+        # hit, correctly separated by the blank lines around them (4 and 6).
+        expect(hits[5]).to be > 0
+        expect(hits[7]).to be > 0
+        expect(hits[4]).to be_nil
+        expect(hits[6]).to be_nil
+      end
+    end
+  end
+end

data/spec/units/c_extractor/c_extractor_declarations_spec.rb

@@ -445,6 +445,58 @@ describe CExtractorDeclarations do
       end
     end
 
+    context "escape sequences in string literal initializers" do
+      it "extracts pointer variable with escaped quote in string literal initializer" do
+        content = 'char* s = "say \"hi\"";'
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 's', type: 'char*', text: 'char* s = "say \"hi\"";')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts pointer variable with escaped backslash in string literal initializer" do
+        content = 'char* s = "C:\\\\dir";'
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 's', type: 'char*', text: 'char* s = "C:\\\\dir";')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts pointer variable with escaped newline in string literal initializer" do
+        content = 'char* s = "line1\\nline2";'
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 's', type: 'char*', text: 'char* s = "line1\\nline2";')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts pointer variable with hex escape in string literal initializer" do
+        content = 'char* s = "\\x41\\x42";'
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 's', type: 'char*', text: 'char* s = "\\x41\\x42";')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts pointer variable with octal escape in string literal initializer" do
+        content = 'char* s = "\\101\\102";'
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 's', type: 'char*', text: 'char* s = "\\101\\102";')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+    end
+
     context "qualified type declarations" do
       it "extracts const variable" do
         content = "const int value;"
@@ -685,6 +737,82 @@ describe CExtractorDeclarations do
       end
     end
 
+    context "multiline declarations" do
+      it "extracts array declaration whose closing brace and semicolon fall on the final line after multiline data (GH #1182)" do
+        content = "static uint8_t arr[10] = {\n    0x00, 0x01, 0x02, 0x03, 0x04,\n    0x05, 0x06, 0x07, 0x08, 0x09\n};"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'arr', type: 'uint8_t', decorators: ['static'],
+                     text: 'uint8_t arr[10] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };',
+                     array_suffix: '[10]')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts nested multi-dimensional array initializer whose closing braces and semicolon fall on the final line" do
+        content = "static int matrix[2][3] = {\n    {1, 2, 3},\n    {4, 5, 6}\n};"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'matrix', type: 'int', decorators: ['static'],
+                     text: 'int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} };',
+                     array_suffix: '[2][3]')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "expands a compound declaration whose second declarator has a multiline brace initializer" do
+        content = "static int a, arr[3] = {\n    1,\n    2,\n    3\n};"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        expect(variable.length).to eq 2
+
+        expect(variable[0].name).to eq 'a'
+        expect(variable[0].decorators).to eq ['static']
+        expect(variable[0].text).to eq 'int a;'
+
+        expect(variable[1].name).to eq 'arr'
+        expect(variable[1].decorators).to eq ['static']
+        expect(variable[1].array_suffix).to eq '[3]'
+        expect(variable[1].text).to eq 'int arr[3] = { 1, 2, 3 };'
+
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts a declaration with the type and name split across lines and no braces involved" do
+        content = "int\n    x;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'x', type: 'int', text: 'int x;')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts a declaration whose initializer value falls on the line after the assignment" do
+        content = "int x =\n    5;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'x', type: 'int', text: 'int x = 5;')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts a declaration whose terminating semicolon is alone on the line following a bracketed declarator" do
+        content = "int arr[10]\n;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'arr', type: 'int', text: 'int arr[10] ;', array_suffix: '[10]')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+    end
+
     context "array_suffix field" do
       it "returns empty string for a scalar variable" do
         content = "static uint8 s_count;"

data/spec/units/c_extractor/c_extractor_definitions_spec.rb

@@ -295,6 +295,13 @@ describe CExtractorDefinitions do
       expect(pos).to eq input.length
     end
 
+    it "extracts a named struct when the closing '}' and terminating ';' fall on separate lines" do
+      input = "struct Point {\n  int x;\n}\n;\n"
+      result, pos = try_aggregate(input)
+      expect(result).to eq [true, input.chomp]
+      expect(pos).to eq input.length
+    end
+
     it "extracts an anonymous struct (no tag name)" do
       input = "struct { int x; int y; };\n"
       result, pos = try_aggregate(input)

data/spec/units/c_extractor/c_extractor_integration_spec.rb

@@ -561,6 +561,23 @@ describe CExtractor do
       expect( contents.variable_declarations.length ).to eq 0
     end
 
+    it "should extract a function definition following a #define with an escaped character in a string literal (GH #1184)" do
+      file_contents = <<~'CONTENTS'
+      #include "world.h"
+      #define SZ1 sizeof("\n")
+      void helloWorld() { return; }
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect( contents.macro_definitions.length ).to eq 1
+      expect( contents.macro_definitions[0].text ).to eq '#define SZ1 sizeof("\n")'
+
+      expect( contents.function_definitions.length ).to eq 1
+      expect( contents.function_definitions[0].name ).to eq 'helloWorld'
+      expect( contents.function_definitions[0].body ).to eq '{ return; }'
+    end
+
     it "should consume #pragma and #include directives without storing them" do
       file_contents = <<~CONTENTS
       #pragma once

data/spec/units/c_extractor/c_extractor_preprocessing_spec.rb

@@ -290,6 +290,45 @@ describe CExtractorPreprocessing do
       expect(pos).to eq input.length
     end
 
+    # --- Regression: GH #1184 — escape sequences inside a #define string literal ---
+    # A lone '\' preceding a string-literal escape (e.g. \n, \", \\) is not a line
+    # continuation and must not be mistaken for one, truncating the directive.
+
+    it "extracts a #define whose string literal contains an escaped newline" do
+      input = "#define SZ1 sizeof(\"\\n\")\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "extracts a #define whose string literal contains an escaped quote" do
+      input = "#define MSG \"say \\\"hi\\\"\"\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "extracts a #define whose string literal contains an escaped backslash" do
+      input = "#define PATH \"C:\\\\dir\"\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "extracts a #define with an escaped character and no trailing newline (EOS)" do
+      input = "#define SZ1 sizeof(\"\\n\")"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input]
+      expect(pos).to eq input.length
+    end
+
+    it "does not consume a following function definition after a #define with an escaped character" do
+      input = "#define SZ1 sizeof(\"\\n\")\nvoid helloWorld() { return; }\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, "#define SZ1 sizeof(\"\\n\")"]
+      expect(pos).to eq "#define SZ1 sizeof(\"\\n\")\n".length
+    end
+
     it "stops at end of directive and does not consume following code" do
       input = "#define FOO 1\nint x = 0;"
       result, pos = try_directive(input)
@@ -483,6 +522,13 @@ describe CExtractorPreprocessing do
       expect(pos).to eq input.length
     end
 
+    it "handles a static assert whose terminating ';' falls on its own line after the closing ')'" do
+      input = "static_assert(sizeof(int) == 4, \"msg\")\n;\n"
+      result, pos = try_static_assert(input)
+      expect(result[0]).to be true
+      expect(pos).to eq input.length
+    end
+
     # --- Boundary behaviour ---
 
     it "stops at the ';' and does not consume following code" do

data/spec/units/generators/generator_partials_spec.rb

@@ -84,12 +84,14 @@ describe GeneratorPartials do
       header_file_handle = double('header_file_handle')
       source_file_handle = double('source_file_handle')
 
+      # Binary mode ('wb'): generated files carry embedded content whose line
+      # endings must reach disk unchanged, which text mode would not guarantee.
       allow(@file_wrapper).to receive(:open)
-        .with(expected_header_filepath, 'w')
+        .with(expected_header_filepath, 'wb')
         .and_yield(header_file_handle)
 
       allow(@file_wrapper).to receive(:open)
-        .with(expected_source_filepath, 'w')
+        .with(expected_source_filepath, 'wb')
         .and_yield(source_file_handle)
 
       # Spy on generate_header and generate_source -- allow them to be called but track the calls
@@ -145,8 +147,8 @@ describe GeneratorPartials do
       expect(@file_path_utils).to have_received(:form_partial_implementation_header_filename).with(name)
 
       # Verify file operations
-      expect(@file_wrapper).to have_received(:open).with(expected_header_filepath, 'w')
-      expect(@file_wrapper).to have_received(:open).with(expected_source_filepath, 'w')
+      expect(@file_wrapper).to have_received(:open).with(expected_header_filepath, 'wb')
+      expect(@file_wrapper).to have_received(:open).with(expected_source_filepath, 'wb')
 
       # Verify return value is the source filepath
       expect(result).to eq(expected_source_filepath)
@@ -167,9 +169,11 @@ describe GeneratorPartials do
         .and_return(header_filename)
 
       # Mock FileWrapper.open to yield a file handle
+      # Binary mode ('wb'): generated files carry embedded content whose line
+      # endings must reach disk unchanged, which text mode would not guarantee.
       file_handle = double('file_handle')
       allow(@file_wrapper).to receive(:open)
-        .with(expected_filepath, 'w')
+        .with(expected_filepath, 'wb')
         .and_yield(file_handle)
 
       # Spy on generate_header -- allow it to be called but track the call
@@ -211,7 +215,7 @@ describe GeneratorPartials do
       expect(@file_path_utils).to have_received(:form_partial_interface_header_filename).with(name)
 
       # Verify file operations
-      expect(@file_wrapper).to have_received(:open).with(expected_filepath, 'w')
+      expect(@file_wrapper).to have_received(:open).with(expected_filepath, 'wb')
 
       # Verify return value is the header filepath
       expect(result).to eq(expected_filepath)
@@ -649,6 +653,28 @@ describe GeneratorPartials do
       expect( buf.string.strip() ).to eq file_contents.strip()
     end
 
+    it "should pass a code_block's line endings through unchanged, including embedded CRLF" do
+      # code_block content is written to the IO handle exactly as given, byte for
+      # byte, since the file it ends up in is opened by its caller in binary mode
+      # specifically so nothing here alters a line ending already present in it.
+      code_block_with_crlf = "void helloBlanks(void) {\r\n\r\n  return;\r\n}"
+
+      defn = Partials.manufacture_function_definition(
+        line_num: 2,
+        source_filepath: 'src/blanks.c',
+        name: 'helloBlanks',
+        signature: 'void helloBlanks(void)',
+        code_block: code_block_with_crlf
+      )
+      c_module = make_module(
+        CExtractorTypes::CFunctionDefinition.new(name: 'helloBlanks')
+      )
+
+      @generator.send(:generate_source, buf, [], [defn], c_module)
+
+      expect( buf.string ).to include( code_block_with_crlf )
+    end
+
     it "should emit only variable declarations and function definitions from all four element_sequence categories" do
       # Source generation emits two categories and silently skips two others:
       #   CVariableDeclaration  → emitted as-is