ceedling 1.1.7 → 1.1.9

data/plugins/gcov/lib/gcovr_reportinator.rb

@@ -66,9 +66,12 @@ class GcovrReportinator < GcovReportinator
       )
     end
 
-    if gcovr_opts[:decisions] && !min_version?( @gcovr_version, 6, 0 )
+    # --decisions was introduced in gcovr 5.1, not 6.0 -- confirmed directly against
+    # gcovr's own changelog and a real gcovr 5.1/5.0 install (5.1 accepts --decisions
+    # and proceeds; 5.0 rejects it outright as unrecognized).
+    if gcovr_opts[:decisions] && !min_version?( @gcovr_version, 5, 1 )
       raise CeedlingException.new(
-        ":gcov ↳ :gcovr ↳ :decisions ➡️ requires gcovr 6 or higher " \
+        ":gcov ↳ :gcovr ↳ :decisions ➡️ requires gcovr 5.1 or higher " \
         "(found #{@gcovr_version.major}.#{@gcovr_version.minor})"
       )
     end
@@ -116,9 +119,18 @@ class GcovrReportinator < GcovReportinator
     args += "--gcov-filter \"#{gcovr_opts[:gcov_filter]}\" " unless gcovr_opts[:gcov_filter].nil?
     args += "--gcov-exclude \"#{gcovr_opts[:gcov_exclude]}\" " unless gcovr_opts[:gcov_exclude].nil?
     args += "--exclude-directories \"#{gcovr_opts[:exclude_directories]}\" " unless gcovr_opts[:exclude_directories].nil?
-    args += "--branches " if gcovr_opts[:branches]
-    args += "--sort-uncovered " if gcovr_opts[:sort_uncovered]
-    args += "--sort-percentage " if gcovr_opts[:sort_percentage]
+    # gcovr 7.0 deprecated --branches/--sort-uncovered/--sort-percentage in favor of
+    # these renamed equivalents (still functional, but warn, below 7.0); use whichever
+    # form the detected gcovr_version actually expects.
+    if gcovr_opts[:branches]
+      args += (min_version?(gcovr_version, 7, 0) ? "--txt-metric branch " : "--branches ")
+    end
+    if gcovr_opts[:sort_uncovered]
+      args += (min_version?(gcovr_version, 7, 0) ? "--sort uncovered-number " : "--sort-uncovered ")
+    end
+    if gcovr_opts[:sort_percentage]
+      args += (min_version?(gcovr_version, 7, 0) ? "--sort uncovered-percent " : "--sort-percentage ")
+    end
     args += "--print-summary " if gcovr_opts[:print_summary]
     args += "--gcov-executable \"#{gcovr_opts[:gcov_executable]}\" " unless gcovr_opts[:gcov_executable].nil?
     args += "--exclude-unreachable-branches " if gcovr_opts[:exclude_unreachable_branches]
@@ -152,18 +164,24 @@ class GcovrReportinator < GcovReportinator
       next if gcovr_opts[opt].nil?
 
       value = gcovr_opts[opt]
-      
+
       # Value sanity checks for :fail_under_* settings
       if opt.to_s =~ /fail_/
         if not value.is_a? Integer
           raise CeedlingException.new(":gcov ↳ :gcovr ↳ :#{opt} ➡️ '#{value}' must be an integer")
-        elsif (value < 0) || (value > 100)
-          raise CeedlingException.new(":gcov ↳ :gcovr ↳ :#{opt} ➡️ '#{value}' must be an integer percentage 0 – 100")
+        elsif (value < 1) || (value > 100)
+          raise CeedlingException.new(":gcov ↳ :gcovr ↳ :#{opt} ➡️ '#{value}' must be an integer percentage 1 – 100")
         end
       end
-      
-      # If the YAML key has a value, trasnform key into command line argument with value and concatenate
-      args += "--#{opt.to_s.gsub('_','-')} #{value} " unless value.nil?
+
+      # :source_encoding/:object_directory are quoted (unlike the already-validated,
+      # always-integer :fail_under_* values) so a value containing a space doesn't
+      # break the constructed command line.
+      if [:source_encoding, :object_directory].include?(opt)
+        args += "--#{opt.to_s.gsub('_','-')} \"#{value}\" " unless value.nil?
+      else
+        args += "--#{opt.to_s.gsub('_','-')} #{value} " unless value.nil?
+      end
     end
 
     return args
@@ -409,7 +427,12 @@ class GcovrReportinator < GcovReportinator
       _opts[:report_exclude] = excludes unless excludes.empty?
     end
 
-    _opts[:mcdc] = true if opts[:gcov_mcdc]
+    # No :mcdc-specific gcovr flag to set here -- GCC's own condition/MC-DC data flows
+    # into gcovr's reports unconditionally, in every format, regardless of --decisions
+    # (confirmed directly: gcovr's Condition-labeled HTML/JSON content is byte-identical
+    # with and without --decisions; that flag only adds its own separate, additive
+    # Decision data alongside it). :mcdc's own gcovr-version floor is still enforced in
+    # initialize -- there's just nothing more for gcovr's own CLI args to do here.
 
     return _opts
   end
@@ -417,22 +440,29 @@ class GcovrReportinator < GcovReportinator
 
   # Build a combined Python regex for gcovr's `--exclude` flag covering all
   # non-production file categories: test files, support files, and generated/framework files.
+  # Path/prefix values are config-driven, so they're Regexp-escaped -- interpolated raw, a
+  # metacharacter (e.g. a literal '.') in a project's own path would silently over- or
+  # under-match.
   def build_report_exclusions
     data = build_exclusion_data
     patterns = []
 
+    test_prefix    = Regexp.escape(data[:test_prefix].to_s)
+    build_root     = Regexp.escape(data[:build_root].to_s)
+    src_extension  = Regexp.escape(data[:src_extension].to_s)
+
     data[:test_paths].each do |path|
       # Test files (e.g. test_foo.c)
-      patterns << ".*#{path}.*/#{data[:test_prefix]}.+\\#{data[:src_extension]}$"
+      patterns << ".*#{Regexp.escape(path)}.*/#{test_prefix}.+\\#{src_extension}$"
     end
 
     # Support files (e.g. helpers, stubs, fixtures) — never production source
     data[:support_paths].each do |path|
-      patterns << ".*#{path}/.+\\#{data[:src_extension]}$"
+      patterns << ".*#{Regexp.escape(path)}/.+\\#{src_extension}$"
     end
 
     # Any generated files for tests or vendored framework C source files below the root of the build directory
-    patterns << ".*#{data[:build_root]}/.+\\#{EXTENSION_CORE_SOURCE}$"
+    patterns << ".*#{build_root}/.+\\#{EXTENSION_CORE_SOURCE}$"
 
     return patterns
   end
@@ -535,59 +565,43 @@ class GcovrReportinator < GcovReportinator
 
   # Output to console a human-friendly message on certain coverage failure exit codes.
   # Prefers the actual gcovr error text from stderr; falls back to descriptive strings.
-  # Perform the logic on whether to raise an exception
+  # gcovr's composite exit code bit-ORs every violated :fail_under_* threshold together --
+  # every violated bit is collected and reported, not just whichever is checked first.
   def gcovr_exec_exception?(opts, exitcode, boom, shell_result=nil)
+    violations = []
 
     # Special handling of exit code 2 with --fail-under-line
     if ((exitcode & 2) == 2) and !opts[:fail_under_line].nil?
       fallback = "Line coverage is less than the configured minimum of #{opts[:fail_under_line]}%"
-      msg = "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
-      if boom
-        raise CeedlingException.new(msg)
-      else
-        @loginator.log( msg, Verbosity::COMPLAIN )
-        # Clear bit in exit code
-        exitcode &= ~2
-      end
+      violations << "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
+      exitcode &= ~2
     end
 
     # Special handling of exit code 4 with --fail-under-branch
     if ((exitcode & 4) == 4) and !opts[:fail_under_branch].nil?
       fallback = "Branch coverage is less than the configured minimum of #{opts[:fail_under_branch]}%"
-      msg = "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
-      if boom
-        raise CeedlingException.new(msg)
-      else
-        @loginator.log( msg, Verbosity::COMPLAIN )
-        # Clear bit in exit code
-        exitcode &= ~4
-      end
+      violations << "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
+      exitcode &= ~4
     end
 
     # Special handling of exit code 8 with --fail-under-decision
     if ((exitcode & 8) == 8) and !opts[:fail_under_decision].nil?
       fallback = "Decision coverage is less than the configured minimum of #{opts[:fail_under_decision]}%"
-      msg = "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
-      if boom
-        raise CeedlingException.new(msg)
-      else
-        @loginator.log( msg, Verbosity::COMPLAIN )
-        # Clear bit in exit code
-        exitcode &= ~8
-      end
+      violations << "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
+      exitcode &= ~8
     end
 
     # Special handling of exit code 16 with --fail-under-function
     if ((exitcode & 16) == 16) and !opts[:fail_under_function].nil?
       fallback = "Function coverage is less than the configured minimum of #{opts[:fail_under_function]}%"
-      msg = "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
-      if boom
-        raise CeedlingException.new(msg)
-      else
-        @loginator.log( msg, Verbosity::COMPLAIN )
-        # Clear bit in exit code
-        exitcode &= ~16
-      end
+      violations << "Gcovr ⏩️ #{extract_gcovr_error_message( shell_result ) || fallback}"
+      exitcode &= ~16
+    end
+
+    if boom
+      raise CeedlingException.new( violations.join("\n") ) unless violations.empty?
+    else
+      violations.each { |msg| @loginator.log( msg, Verbosity::COMPLAIN ) }
     end
 
     # A non-zero exit code is a problem

data/plugins/gcov/lib/reportgenerator_reportinator.rb

@@ -128,7 +128,9 @@ class ReportGeneratorReportinator < GcovReportinator
 
   # Get the ReportGenerator options from the project options.
   def collect_reportgenerator_opts(opts)
-    _opts = opts[REPORT_GENERATOR_SETTING_PREFIX.to_sym]
+    # dup prevents repeated calls from accumulating mutations on the shared opts hash --
+    # mirrors GcovrReportinator#collect_gcovr_opts' identical guard and rationale.
+    _opts = opts[REPORT_GENERATOR_SETTING_PREFIX.to_sym].dup
 
     # Auto-generate -filefilters: exclusion patterns for test paths and the build root.
     # These exclude test files and all generated/framework files from coverage reports.
@@ -275,17 +277,19 @@ class ReportGeneratorReportinator < GcovReportinator
   # Build filename-fragment patterns for the .gcno scan exclusion regex.
   # Excludes test files, generated mocks, and test runners from gcov processing.
   # The '.*' suffix handles source extensions embedded in .gcno filenames (e.g. test_foo.c.gcno).
+  # test_prefix/mock_prefix are config-driven, so they're Regexp-escaped -- unescaped, a
+  # metacharacter in either (e.g. a literal '.') would silently over- or under-match.
   def build_gcno_exclusions
     data = build_exclusion_data
     # Use [^\/\\]* (no path separators) rather than .* to match filenames only.
     # Ceedling names build output dirs after test files (e.g. build/gcov/out/test_foo/),
     # so .* would greedily match test_foo/bar.c and exclude ALL production sources.
     [
-      "#{data[:test_prefix]}[^\\/\\\\]*",  # test_foo.gcno
-      "#{data[:mock_prefix]}[^\\/\\\\]*",  # MockBar.gcno
-      "[^\\/\\\\]*_runner[^\\/\\\\]*",     # test_foo_runner.gcno
-      File.basename(UNITY_C_FILE, '.*'),   # unity.gcno
-      File.basename(CMOCK_C_FILE, '.*')    # cmock.gcno
+      "#{Regexp.escape(data[:test_prefix].to_s)}[^\\/\\\\]*",  # test_foo.gcno
+      "#{Regexp.escape(data[:mock_prefix].to_s)}[^\\/\\\\]*",  # MockBar.gcno
+      "[^\\/\\\\]*_runner[^\\/\\\\]*",                          # test_foo_runner.gcno
+      Regexp.escape(File.basename(UNITY_C_FILE, '.*')),        # unity.gcno
+      Regexp.escape(File.basename(CMOCK_C_FILE, '.*'))         # cmock.gcno
     ]
   end
 

data/site-local/plugins/gcov/gcovr.html

@@ -5367,7 +5367,7 @@ it's never silently non-functional.</p>
 <p>Report the decision coverage. For HTML, JSON, and the summary report.
 (<code>gcovr --decisions</code>)</p>
 <p>Implied automatically whenever <code>:fail_under_decision</code> is set.</p>
-<p><strong>Requires:</strong> <code>gcovr</code> 6.0 or higher</p>
+<p><strong>Requires:</strong> <code>gcovr</code> 5.1 or higher</p>
 <hr />
 <h3 id="fail_under_function"><code>:fail_under_function</code></h3>
 <p>Exit with a status of 16 if the total function coverage is less than this minimum
@@ -5387,15 +5387,20 @@ logs a warning without breaking the build.</p>
 <hr />
 <h3 id="branches"><code>:branches</code></h3>
 <p>Report the branch coverage instead of the line coverage. Applies to the text
-report only. (<code>gcovr --branches</code>)</p>
+report only. Uses <code>gcovr --txt-metric branch</code> on <code>gcovr</code> 7.0+ (<code>--branches</code> is
+deprecated as of 7.0, though still functional); <code>gcovr --branches</code> below it.</p>
 <hr />
 <h3 id="sort_uncovered"><code>:sort_uncovered</code></h3>
 <p>Sort entries by increasing number of uncovered lines. Applies to text and HTML
-reports. (<code>gcovr --sort-uncovered</code>)</p>
+reports. Uses <code>gcovr --sort uncovered-number</code> on <code>gcovr</code> 7.0+
+(<code>--sort-uncovered</code> is deprecated as of 7.0, though still functional);
+<code>gcovr --sort-uncovered</code> below it.</p>
 <hr />
 <h3 id="sort_percentage"><code>:sort_percentage</code></h3>
 <p>Sort entries by increasing percentage of uncovered lines. Applies to text and
-HTML reports. (<code>gcovr --sort-percentage</code>)</p>
+HTML reports. Uses <code>gcovr --sort uncovered-percent</code> on <code>gcovr</code> 7.0+
+(<code>--sort-percentage</code> is deprecated as of 7.0, though still functional);
+<code>gcovr --sort-percentage</code> below it.</p>
 <hr />
 <h3 id="print_summary"><code>:print_summary</code></h3>
 <p>Print a small report to stdout with line and branch percentage coverage. This

data/site-local/reference/gcov-plugin.html

@@ -5668,7 +5668,7 @@ present — setting this option implies <code>:decisions</code> (below) automati
 <p>Report the decision coverage. For HTML, JSON, and the summary report.
 (<code>gcovr --decisions</code>)</p>
 <p>Implied automatically whenever <code>:fail_under_decision</code> is set.</p>
-<p><strong>Requires:</strong> <code>gcovr</code> 6.0 or higher</p>
+<p><strong>Requires:</strong> <code>gcovr</code> 5.1 or higher</p>
 <hr />
 <h3 id="fail_under_function"><code>:fail_under_function</code></h3>
 <p>Exit with status 16 if total function coverage is below this percentage.
@@ -5686,15 +5686,20 @@ instead of only logging a warning.</p>
 <hr />
 <h3 id="branches"><code>:branches</code></h3>
 <p>Report branch coverage instead of line coverage. Applies to text reports only.
-(<code>gcovr --branches</code>)</p>
+Uses <code>gcovr --txt-metric branch</code> on <code>gcovr</code> 7.0+ (<code>--branches</code> is deprecated as
+of 7.0, though still functional); <code>gcovr --branches</code> below it.</p>
 <hr />
 <h3 id="sort_uncovered"><code>:sort_uncovered</code></h3>
 <p>Sort report entries by increasing number of uncovered lines. Applies to text
-and HTML reports. (<code>gcovr --sort-uncovered</code>)</p>
+and HTML reports. Uses <code>gcovr --sort uncovered-number</code> on <code>gcovr</code> 7.0+
+(<code>--sort-uncovered</code> is deprecated as of 7.0, though still functional);
+<code>gcovr --sort-uncovered</code> below it.</p>
 <hr />
 <h3 id="sort_percentage"><code>:sort_percentage</code></h3>
 <p>Sort report entries by increasing percentage of uncovered lines. Applies to
-text and HTML reports. (<code>gcovr --sort-percentage</code>)</p>
+text and HTML reports. Uses <code>gcovr --sort uncovered-percent</code> on <code>gcovr</code> 7.0+
+(<code>--sort-percentage</code> is deprecated as of 7.0, though still functional);
+<code>gcovr --sort-percentage</code> below it.</p>
 <hr />
 <h3 id="print_summary"><code>:print_summary</code></h3>
 <p>Print a brief line- and branch-coverage summary to stdout in addition to any

data/spec/system/gcov_deployment_spec.rb

@@ -37,6 +37,7 @@ ceedling_system_tests do
       test_case :project_with_gcov_success
       test_case :project_with_gcov_fail
       test_case :project_with_gcov_fail_under_decision
+      test_case :project_with_gcov_fail_under_line_rejects_zero
       test_case :gcov_console_report_with_system_header
       test_case :gcov_console_report_with_partial
       # TODO: Restore these tests when the :abort_on_uncovered option is restored in the Gcov plugin

data/spec/system/support/gcov_common_test_cases.rb

@@ -98,6 +98,24 @@ module GcovCommonTestCases
     end
   end
 
+  # :fail_under_* documents a 1-100 range; 0 was previously silently accepted as a
+  # threshold that could never actually fail (0% coverage is always >= 0).
+  def project_with_gcov_fail_under_line_rejects_zero
+    @c.with_context do
+      Dir.chdir @proj_name do
+        prep_project_yml_for_coverage
+        @c.merge_project_yml_for_test( { :gcov => { :gcovr => { :fail_under_line => 0 } } } )
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
+
+        output = @c.ceedling_build_exec("gcov:all")
+        expect(@c.last_exit_status).to_not eq(0)
+        expect(output).to match(/:fail_under_line.*must be an integer percentage/)
+      end
+    end
+  end
+
   # TODO: Restore this test when the :abort_on_uncovered option is restored in the Gcov plugin
   # def project_with_gcov_fail_because_of_uncovered_files
   #   @c.with_context do

data/spec/units/c_extractor/c_extractor_declarations_spec.rb

@@ -52,6 +52,22 @@ describe CExtractorDeclarations do
         expect(rest).to eq("")
       end
 
+      # #1266 follow-on: same unanchored-substring risk class as #1262/#1266. The type-side
+      # identifier "counter_t" itself contains "count" as a substring; a plain rindex(name)
+      # would still find the real trailing occurrence here (rindex searches right-to-left),
+      # but this pins down that the \b-anchored match extract_type now uses doesn't regress
+      # this ordinary case, where the type name happens to share a substring with the
+      # declared name.
+      it "extracts a variable whose type name contains the variable's own name as a substring" do
+        content = "counter_t count;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        check_single(variable, name: 'count', type: 'counter_t', text: 'counter_t count;')
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
       it "extracts simple char variable" do
         content = "char c;"
         success, variable, pos, rest = extract_variable.call(content)

data/spec/units/c_extractor/c_extractor_integration_spec.rb

@@ -565,6 +565,59 @@ describe CExtractor do
       expect( contents.variable_declarations.length ).to eq 0
     end
 
+    # #1262: Partials-generated headers occasionally concatenated two adjacent
+    # #define lines onto one physical line. Reconstructing the joined text
+    # from element_sequence (as generator_partials.rb does) rules the plain,
+    # comment-free case in or out formally, rather than by inspection of
+    # #_collect_directive alone. This shape -- three plain register-offset
+    # macros in a row, no comments -- is expected to reconstruct cleanly.
+    it "reconstructs three adjacent plain #define macros joined by newlines with no text lost between them" do
+      file_contents = <<~'CONTENTS'
+      #define START_ADDRESS 0x00
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect( contents.macro_definitions.length ).to eq 3
+      joined = contents.element_sequence.map(&:text).join("\n")
+      expect( joined ).to eq(
+        "#define START_ADDRESS 0x00\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+      )
+    end
+
+    # #1262's actual reported trigger: a trailing // comment on one #define containing
+    # an ordinary English contraction. The stray apostrophe used to be scanned as the
+    # start of a char literal, sending the directive scanner hunting for a closing
+    # match straight through this macro's own newline and into the next two #defines
+    # -- merging all three into one macro_definitions entry with no separating newline,
+    # which is exactly what later caused Partials-generated headers to concatenate two
+    # #define lines onto one physical line ("stray '#' in program").
+    it "reconstructs three adjacent #define macros when one has a trailing comment with an apostrophe" do
+      file_contents = <<~'CONTENTS'
+      #define START_ADDRESS 0x00 // don't change this
+      #define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)
+      #define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect( contents.macro_definitions.length ).to eq 3
+      expect( contents.macro_definitions[0].text ).to eq "#define START_ADDRESS 0x00 // don't change this"
+      expect( contents.macro_definitions[1].text ).to eq "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)"
+      expect( contents.macro_definitions[2].text ).to eq "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+
+      joined = contents.element_sequence.map(&:text).join("\n")
+      expect( joined ).to eq(
+        "#define START_ADDRESS 0x00 // don't change this\n" +
+        "#define IDX_DATARATE (ADS124S08_REG_ADDR_DATARATE - START_ADDRESS)\n" +
+        "#define IDX_REF (ADS124S08_REG_ADDR_REF - START_ADDRESS)"
+      )
+    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"
@@ -954,6 +1007,24 @@ describe CExtractor do
       expect(plain.decorators).to eq([])
     end
 
+    it "normalizes a preprocessor-inserted space before ## in a backslash-continued macro definition" do
+      file_contents = <<~CONTENTS
+      #define MODULE_DEV_TYPE_CB(dev_type)      \\
+          void MODULE_TrigCbDev ##dev_type(void) \\
+          {                                     \\
+              MODULE_CommonTrigCb();            \\
+          }
+
+      static AlertEntry_t s_alert_table[ALERT_MANAGER_MAX_ALERTS];
+      CONTENTS
+
+      contents = extract_from.call(file_contents)
+
+      expect(contents.macro_definitions.length).to eq 1
+      expect(contents.macro_definitions[0].text).to include('MODULE_TrigCbDev##dev_type')
+      expect(contents.macro_definitions[0].text).not_to include('MODULE_TrigCbDev ##dev_type')
+    end
+
   end
 
 end

data/spec/units/c_extractor/c_extractor_preprocessing_spec.rb

@@ -336,6 +336,51 @@ describe CExtractorPreprocessing do
       expect(pos).to eq "#define FOO 1\n".length
     end
 
+    # --- Regression: GH #1262 — a trailing // comment's apostrophe/quote merges
+    # the next directive into this one ---
+    # A '\'' or '"' inside an ordinary // comment (e.g. an English contraction
+    # like "don't") is not a string/char literal delimiter. Scanned as one
+    # anyway, it sends skip_c_string hunting for a closing match straight through
+    # this directive's own newline and into whatever follows, silently merging
+    # the next #define's text (and losing the newline between them) into this one.
+
+    it "extracts a #define with a trailing // comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 // don't change this\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "does not consume a following #define after a // comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 // don't change this\n#define IDX 1\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, "#define START_ADDRESS 0x00 // don't change this"]
+      expect(pos).to eq "#define START_ADDRESS 0x00 // don't change this\n".length
+    end
+
+    it "does not consume a following #define after a // comment containing a double quote" do
+      input = %(#define LABEL "unbalanced) + %( quote in a comment: "\n#define IDX 1\n)
+      result, pos = try_directive(input)
+      expect(result[0]).to eq true
+      expect(result[1]).to start_with('#define LABEL')
+      expect(pos).to be < input.length
+      expect(input[pos..]).to eq "#define IDX 1\n"
+    end
+
+    it "extracts a #define with a trailing /* */ comment containing an apostrophe" do
+      input = "#define START_ADDRESS 0x00 /* don't change this */\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
+    it "carries a directive across physical lines when a // comment's own line ends in a backslash" do
+      input = "#define MACRO(x) \\\n  // comment continues \\\n  do_thing(x);\n"
+      result, pos = try_directive(input)
+      expect(result).to eq [true, input.rstrip]
+      expect(pos).to eq input.length
+    end
+
     it "leaves scanner position unchanged on failure" do
       scanner = StringScanner.new("int x;")
       scanner.pos = 0
@@ -343,6 +388,83 @@ describe CExtractorPreprocessing do
       expect(scanner.pos).to eq 0
     end
 
+    context "whitespace around # and ## operators" do
+      it "trims a space before ##" do
+        result, _pos = try_directive("#define M(x) void f ##x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims a space after ##" do
+        result, _pos = try_directive("#define M(x) void f## x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims space on both sides of ##" do
+        result, _pos = try_directive("#define M(x) void f ## x(void) { g(); }\n")
+        expect(result).to eq [true, "#define M(x) void f##x(void) { g(); }"]
+      end
+
+      it "trims a space after the stringize operator #" do
+        result, _pos = try_directive("#define S(x) # x\n")
+        expect(result).to eq [true, "#define S(x) #x"]
+      end
+
+      it "trims a space before a stringize operator directly gluing onto a preceding identifier" do
+        result, _pos = try_directive("#define M(a, b) a #b\n")
+        expect(result).to eq [true, "#define M(a, b) a#b"]
+      end
+
+      it "does not touch whitespace before # or ## when preceded by punctuation, not an identifier being pasted" do
+        # The space here separates the macro's own parameter list from a
+        # replacement list that happens to start with the operator -- that's
+        # ordinary formatting, not preprocessor-reconstruction spacing around an
+        # operand being pasted, so it's out of this fix's scope.
+        result, _pos = try_directive("#define S(x)  #x\n")
+        expect(result).to eq [true, "#define S(x)  #x"]
+      end
+
+      it "normalizes the GNU comma-deletion ,##__VA_ARGS__ form" do
+        result, _pos = try_directive("#define LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)\n")
+        expect(result).to eq [true, "#define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)"]
+      end
+
+      it "is idempotent for already-canonical ## spacing" do
+        input = "#define M(x) void f##x(void) { g(); }\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "is idempotent for already-canonical # spacing" do
+        input = "#define S(x) #x\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a string literal" do
+        input = %q{#define M(x) "a ## b"} + "\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a // comment" do
+        input = "#define M(x) x // a ## b\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "does not touch ## inside a /* */ comment" do
+        input = "#define M(x) x /* a ## b */\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+
+      it "leaves ordinary whitespace unrelated to # or ## untouched" do
+        input = "#define M(x) void  f  (  )  ;\n"
+        result, _pos = try_directive(input)
+        expect(result).to eq [true, input.rstrip]
+      end
+    end
+
   end
 
   context "#filter_directive" do