ceedling 1.1.0 → 1.1.2

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