ceedling 1.1.2 → 1.1.4

data/lib/ceedling/c_extractor/c_extractor_declarations.rb

@@ -16,12 +16,9 @@ class CExtractorDeclarations
 
   constructor :c_extractor_code_text
 
-  attr_writer :max_line_length
-
   def setup()
     # Aliases
-    @code_text       = @c_extractor_code_text
-    @max_line_length = DEFAULT_MAX_LINE_LENGTH
+    @code_text = @c_extractor_code_text
   end
 
   # Attempts to extract a complete variable declaration from the scanner
@@ -58,11 +55,14 @@ class CExtractorDeclarations
   #   On failure: Resets scanner position to starting position
   #
   # Safety:
-  #   Enforces max_line_length limit to prevent infinite loops on malformed input
+  #   A declaration with no terminating semicolon runs the scan to the end of
+  #   whatever buffer the caller (CExtractor#extract_next_feature) has grown so
+  #   far; that caller is the one place enforcing an overall length ceiling,
+  #   since only it knows how much more of the file remains to try growing into.
   def try_extract_variable(scanner)
     start_pos = scanner.pos
 
-    # Tracks paren, bracket, and brace depth simultaneously with inline string state machine and max_line_length guard — not suitable for collect_balanced()
+    # Tracks paren, bracket, and brace depth simultaneously with an inline string state machine — not suitable for collect_balanced()
     paren_depth = 0
     bracket_depth = 0
     brace_depth = 0
@@ -74,12 +74,6 @@ class CExtractorDeclarations
     until scanner.eos?
       char = scanner.peek(1)
 
-      # Safety check -- prevent infinite loops on malformed input
-      if (scanner.pos - start_pos) > @max_line_length
-        scanner.pos = start_pos
-        return [false, nil]
-      end
-
       # Handle string literals
       if in_string
         if char == '\\'
@@ -302,8 +296,8 @@ class CExtractorDeclarations
   #
   # Returns: CVariableDeclaration
   def parse_declaration(individual_text, original_text)
-    decorators      = extract_decorators(individual_text)
-    clean_text      = strip_decorators(individual_text, decorators)
+    decorators, remaining = extract_decorators(individual_text)
+    clean_text      = normalize_declaration_whitespace(remaining)
     # Strip compiler extensions for name/type/array_suffix extraction only;
     # clean_text (stored as .text) retains attributes for correct compilation.
     extraction_text = @code_text.strip_compiler_extensions(clean_text)
@@ -321,9 +315,17 @@ class CExtractorDeclarations
     )
   end
 
-  # Scan leading whole-word tokens against DECORATOR_KEYWORDS
+  # Storage-class specifiers and base-type qualifiers precede a C declaration's type as a
+  # contiguous run of keywords -- `static`, `extern`, and a `const`/`volatile` that qualifies
+  # the type itself all appear here (e.g. `static const int MAX;`). A qualifier bound to a
+  # pointer level instead, such as the second `const` in `char * const p;`, sits after the
+  # type and its `*` tokens rather than in this leading run, so it is grammatically part of
+  # the declarator, not a decorator. Peeling keywords off one at a time from the front, and
+  # stopping at the first non-keyword token, naturally separates the two: the same keyword
+  # (e.g. `const`) can appear once here and again later in the declarator without the two
+  # occurrences being confused with each other, since only the leading run is ever consumed.
   #
-  # Returns: Array<String> ordered decorator keywords found at start of text
+  # Returns: [Array<String> ordered decorator keywords found at start of text, String remaining text after that run]
   def extract_decorators(text)
     decorators = []
     remaining = text.strip
@@ -339,18 +341,17 @@ class CExtractorDeclarations
       end
       break unless matched
     end
-    decorators
+    [decorators, remaining]
   end
 
-  # Remove decorator keywords from text and normalize whitespace
+  # A declaration with its leading decorator run already removed (see extract_decorators)
+  # still carries whatever whitespace and line breaks appeared in the source between its
+  # remaining tokens. This collapses that whitespace to single spaces and guarantees a
+  # trailing semicolon, so `.text` is stable, single-line C ready to compile.
   #
-  # Returns: String with decorators removed, whitespace normalized, semicolon retained
-  def strip_decorators(text, decorators)
-    result = text.dup
-    decorators.each do |kw|
-      result.gsub!(/\b#{Regexp.escape(kw)}\b\s*/, '')
-    end
-    # Normalize whitespace but preserve semicolon
+  # Returns: String with whitespace normalized, semicolon retained
+  def normalize_declaration_whitespace(remaining)
+    result = remaining.dup
     result.gsub!(/\r\n|\r|\n|\t/, ' ')
     result.gsub!(/\s+/, ' ')
     result.strip!

data/lib/ceedling/c_extractor/c_extractor_functions.rb

@@ -15,13 +15,9 @@ class CExtractorFunctions
 
   constructor :c_extractor_code_text
 
-  attr_writer :max_line_length
-
   def setup()
     # Aliases
     @code_text = @c_extractor_code_text
-
-    @max_line_length = DEFAULT_MAX_LINE_LENGTH
   end
 
   def try_extract_function_declaration(scanner)
@@ -124,7 +120,10 @@ class CExtractorFunctions
   #  - Before '{' for definitions)
   #
   # Safety:
-  #   Enforces max_line_length limit to prevent infinite loops on malformed input
+  #   A signature with no terminating ')'/'{' runs the scan to the end of
+  #   whatever buffer the caller (CExtractor#extract_next_feature) has grown so
+  #   far; that caller is the one place enforcing an overall length ceiling,
+  #   since only it knows how much more of the file remains to try growing into.
   def extract_function_signature(scanner, type)
     start_pos = scanner.pos
     # Tracks paren depth while accumulating candidate end-positions — not suitable for collect_balanced()
@@ -133,16 +132,10 @@ class CExtractorFunctions
     string_char = nil
     signature_candidates = []  # Track positions where paren_depth returns to 0
     found_opening_paren = false  # Track if we've seen an opening paren
-    
+
     until scanner.eos?
       char = scanner.peek(1)
 
-      # Safety check
-      if (scanner.pos - start_pos) > @max_line_length
-        scanner.pos = start_pos
-        return nil
-      end
-
       # Handle string literals
       if in_string
         if char == '\\'

data/lib/ceedling/config/configurator.rb

@@ -88,10 +88,16 @@ class Configurator
       @loginator.log( "Reverted :cmock ↳ :treat_inlines to :exclude because this CMock feature is superseded by Partials.", Verbosity::COMPLAIN, LogLabels::NOTICE )
     end
 
-    # If partials enabled, inject partials name prefix symbol to all test compilation.
+    # If partials enabled, inject partials name prefix symbol to all test compilation
+    # and, if a project defines its own preprocess-scoped defines matcher, to
+    # preprocessing as well -- `:preprocess:` defines are looked up independently
+    # of `:test:` defines and only fall back to the latter when `:preprocess:`
+    # is absent entirely, so a project-defined `:preprocess:` matcher needs this
+    # symbol appended directly or Partials' own macro-based #includes break.
     # Handle both the simple list and matcher hash config formats.
     _partials_prefix_symbol = "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}"
     ConfigMatchinator.append_matcher_entries( config[:defines][:test], _partials_prefix_symbol )
+    ConfigMatchinator.append_matcher_entries( config[:defines][:preprocess], _partials_prefix_symbol )
   end
 
 
@@ -750,6 +756,7 @@ class Configurator
     blotter &= @configurator_setup.validate_test_preprocessor( config )
     blotter &= @configurator_setup.validate_backtrace( config )
     blotter &= @configurator_setup.validate_threads( config )
+    blotter &= @configurator_setup.validate_partials( config )
     blotter &= @configurator_setup.validate_plugins( config )
 
     # Informational notices

data/lib/ceedling/config/configurator_setup.rb

@@ -744,6 +744,32 @@ class ConfiguratorSetup
     return valid
   end
 
+  # `:max_extraction_length` is a multiplier of 1000 characters, not a raw character count
+  # (project-file ergonomics -- `5000` reads more clearly than `5000000`). The minimum here
+  # keeps that ceiling comfortably above any ordinary single C declaration or function
+  # signature, catching a value so small it would defeat the setting's own purpose (e.g.
+  # someone setting `1000` expecting "1000 characters" rather than "1000x characters").
+  def validate_partials(config)
+    valid = true
+
+    max_extraction_length = config[:partials][:max_extraction_length]
+
+    walk = @reportinator.generate_config_walk( [:partials, :max_extraction_length] )
+
+    case max_extraction_length
+    when Integer
+      if max_extraction_length < 10
+        @loginator.log( "#{walk} must be at least 10 (10,000 characters)", Verbosity::ERRORS )
+        valid = false
+      end
+    else
+      @loginator.log( "#{walk} is not an integer", Verbosity::ERRORS )
+      valid = false
+    end
+
+    return valid
+  end
+
   def validate_plugins(config)
     missing_plugins =
       Set.new( config[:plugins][:enabled] ) -

data/lib/ceedling/defaults.rb

@@ -69,7 +69,10 @@ DEFAULT_TEST_FIXTURE_SIMPLE_BACKTRACE_TOOL = {
   :name => 'default_test_fixture_simple_backtrace'.freeze,
   :optional => false.freeze,
   :arguments => [
-    '-n ${2}'.freeze # Exact test case name matching flag
+    # Test case matching flag and (quoted) value, fully composed by the caller as
+    # either `-n "<exact name>"` or `-f "<base name>"` -- see
+    # GeneratorTestResultsBacktrace#unity_filter_arg.
+    '${2}'.freeze
     ].freeze
   }
 
@@ -202,7 +205,10 @@ DEFAULT_TEST_BACKTRACE_GDB_TOOL = {
     "--command \"${1}\"".freeze, # Debug script file to run
     '--args'.freeze,
     '${2}'.freeze,               # Test executable
-    '-n ${3}'.freeze             # Exact test case name matching flag
+    # Test case matching flag and (quoted) value, fully composed by the caller as
+    # either `-n "<exact name>"` or `-f "<base name>"` -- see
+    # GeneratorTestResultsBacktrace#unity_filter_arg.
+    '${3}'.freeze
     ].freeze
   }
 
@@ -289,6 +295,14 @@ DEFAULT_CEEDLING_PROJECT_CONFIG = {
     :preprocess_force_fallback => false,
   },
 
+  :partials => {
+    # A single C construct (declaration, definition, directive, etc.) is extracted into a
+    # growing buffer; this bounds how large that buffer may grow before extraction fails
+    # outright rather than silently dropping an oversized construct and everything after
+    # it in the file. Value is a multiplier of 1000 characters -- 5000 means 5,000,000.
+    :max_extraction_length => 5000,
+  },
+
   # Unlike other top-level entries, :environment is an array (of hashes) to preserve order
   :environment => [],
 

data/lib/ceedling/file_path_utils.rb

@@ -303,6 +303,13 @@ class FilePathUtils
     return PARTIAL_FILENAME_PREFIX + _module + '_interface' + EXTENSION_CORE_HEADER
   end
 
+  # A module's typedefs and aggregate (struct/enum/union) definitions are generated into this
+  # standalone header, shared by both the implementation and interface headers below, so a
+  # module tested and mocked in the same file never has its types defined more than once.
+  def form_partial_types_header_filename(_module)
+    return PARTIAL_FILENAME_PREFIX + _module + '_types' + EXTENSION_CORE_HEADER
+  end
+
   def form_mock_partial_interface_header_filename(_module)
     return @configurator.cmock_mock_prefix + PARTIAL_FILENAME_PREFIX + _module + '_interface' + EXTENSION_CORE_HEADER
   end

data/lib/ceedling/file_wrapper.rb

@@ -9,6 +9,7 @@ require 'rubygems'
 require 'rake' # for FileList
 require 'fileutils'
 require 'pathname'
+require 'tmpdir'
 require 'ceedling/constants'
 
 
@@ -132,4 +133,11 @@ class FileWrapper
     return FileUtils.mkdir_p(folder)
   end
 
+  # Creates a uniquely-named, empty directory nested inside `parent` and returns its path.
+  # `parent` must already exist. Collision-free even across concurrent callers targeting
+  # the same `parent` -- Dir.mktmpdir retries internally on name clash.
+  def mkdir_tmp(prefix, parent)
+    return Dir.mktmpdir(prefix, parent)
+  end
+
 end

data/lib/ceedling/generators/generator.rb

@@ -35,6 +35,21 @@ class Generator
     @backtrace = @generator_test_results_backtrace
   end
 
+  # A module's typedefs and aggregate definitions are identical regardless of whether a test
+  # file tests it, mocks it, or both, so they're generated once into their own header here
+  # rather than duplicated by generate_partial_implementation and generate_partial_interface.
+  # Returns the bare generated filename (for the caller to add to each header's own includes
+  # list) or nil when the module has no typedefs or aggregate definitions to share.
+  def generate_partial_types(name:, c_module:, output_path:)
+    arg_hash = {
+      :name => name,
+      :c_module => c_module,
+      :output_path => output_path
+    }
+
+    return @generator_partials.generate_types( **arg_hash )
+  end
+
   def generate_partial_interface(test:, partial:, function_declarations:, includes:, c_module:, input_filepath:, output_path:)
     msg = @reportinator.generate_module_progress(
       operation: "Generating Partial mockable interface for",

data/lib/ceedling/generators/generator_helper.rb

@@ -18,21 +18,40 @@ class GeneratorHelper
 
     crash = false
 
-    # Unix Signal 11 ==> SIGSEGV
-    # Applies to Unix-like systems including MSYS on Windows
-    if (shell_result[:status].termsig == 11)
-      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do 
-        "#{runner} process terminated with SIGSEGV (Unix Signal 11)"
+    # Any signal death is unconditionally a crash, whatever text made it out beforehand.
+    # Broadened from a SIGSEGV(11)-only check: a sanitizer's halt_on_error (UBSan, ASan)
+    # raises SIGABRT, not SIGSEGV, and there's no reason to trust a process that a
+    # signal actually killed regardless of which one. Applies to Unix-like systems
+    # including MSYS on Windows -- native (non-MSYS) Windows Ruby never reports
+    # `signaled?` true at all, so this check is inert there rather than wrong; the
+    # stats-footer and stderr checks below already carry Windows crash detection.
+    if shell_result[:status] && shell_result[:status].signaled?
+      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
+        "#{runner} process terminated by signal #{shell_result[:status].termsig}"
       end
       crash = true
     end
 
     # No test results found in test executable output
-    if (shell_result[:output] =~ PATTERNS::TEST_STDOUT_STATISTICS).nil?
+    stats_match = shell_result[:output].match( PATTERNS::TEST_STDOUT_STATISTICS )
+    if stats_match.nil?
       # No debug logging here because we log this condition in the error log handling below
       crash = true
     end
 
+    # A clean summary (0 failures) is not trustworthy if the real process still exited
+    # nonzero afterward -- e.g. LeakSanitizer detecting a leak during teardown, after
+    # every test case already printed and Unity's own summary already looked clean.
+    # A nonzero exit consistent with Unity's own reported failures (its exit code
+    # convention is one per failed test case) is an ordinary failing run, not a crash.
+    if stats_match && shell_result[:status] && !shell_result[:status].success? &&
+       !shell_result[:status].signaled? && stats_match[2].to_i == 0
+      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
+        "#{runner} reported a clean summary but exited with real status #{shell_result[:status].exitstatus}"
+      end
+      crash = true
+    end
+
     # Scan STDERR line by line for a segfault variant that is not attributed to the test file.
     # A line starting with test_filename is a Unity-reported test-case result, not an OS crash.
     # Checking each line individually avoids false negatives when attributed and bare segfault

data/lib/ceedling/generators/generator_partials.rb

@@ -8,6 +8,7 @@
 require 'ceedling/file_wrapper'
 require 'ceedling/partials/partials'
 require 'ceedling/c_extractor/c_extractor_types'
+require 'ceedling/c_extractor/c_extractor_constants'
 
 class GeneratorPartials
 
@@ -55,8 +56,75 @@ class GeneratorPartials
     return filepath
   end
 
+  # A module's typedefs and aggregate (struct/enum/union) definitions are the same
+  # regardless of which functions a given test file chooses to test versus mock, so they're
+  # generated once here into their own header rather than by generate_header itself. Both
+  # the implementation and interface headers then simply #include this file, which means a
+  # module tested and mocked in the same test file -- each side producing its own generated
+  # header -- never ends up with two separate C definitions of the same type in one
+  # translation unit. Nothing is written and nil is returned when a module has no such
+  # content, since there's then nothing to share.
+  #
+  # @param name     [String] Partial module name (used to form the filename and include guard)
+  # @param c_module [CExtractorTypes::CModule] Merged module with type_definitions/aggregate_definitions
+  # @param output_path [String] Directory shared with the implementation and interface headers
+  # @return [String, nil] The bare filename (for use as a sibling #include), or nil if nothing was generated
+  def generate_types(name:, c_module:, output_path:)
+    return nil if c_module.type_definitions.empty? && c_module.aggregate_definitions.empty?
+
+    header = @file_path_utils.form_partial_types_header_filename(name)
+    filepath = File.join(output_path, header)
+
+    # Binary mode: see generate_implementation above.
+    @file_wrapper.open(filepath, 'wb') do |file|
+      guard = FileWrapper.generate_include_guard(header)
+      file << "#ifndef #{guard}\n"
+      file << "#define #{guard}\n\n"
+
+      anything_emitted = false
+      c_module.element_sequence.each do |item|
+        next unless item.is_a?(CExtractorTypes::CStatement) && type_defining?(item, c_module)
+        file << item.text << "\n"
+        anything_emitted = true
+      end
+
+      file << "\n" if anything_emitted
+      file << "#endif // #{guard}\n\n"
+    end
+
+    return header
+  end
+
   private
 
+  # A typedef or a non-typedef struct/enum/union tag definition establishes a type; C treats
+  # a second definition of the same type in one translation unit as a redefinition error even
+  # when the two definitions are textually identical. A macro statement carries no such
+  # restriction -- an identical #define may legally repeat -- so only membership in
+  # type_definitions or aggregate_definitions marks a CStatement as type-defining content
+  # that belongs in the shared types header instead of being emitted inline.
+  def type_defining?(item, c_module)
+    c_module.type_definitions.include?(item) || c_module.aggregate_definitions.include?(item)
+  end
+
+  # A `CVariableDeclaration`'s `decorators` mixes storage-class specifiers (`static`,
+  # `extern`) with base-type qualifiers (`const`, `volatile`, `restrict`) in their
+  # original source order, since both kinds of keyword lead a declaration the same
+  # way. An `extern` declaration and the variable's own definition both need the
+  # qualifiers reasserted -- omitting them produces a type that disagrees with any
+  # other declaration of the same variable elsewhere in the same translation unit --
+  # but neither may carry a storage-class specifier: `static` would contradict the
+  # external linkage the Partial is establishing, and `extern` is supplied literally
+  # by the caller. Filtering to TYPE_QUALIFIER_KEYWORDS keeps only what belongs on
+  # both forms.
+  #
+  # @param decl [CExtractorTypes::CVariableDeclaration]
+  # @return [String] e.g. "volatile " / "const volatile " / "" (trailing space when non-empty)
+  def qualifier_prefix(decl)
+    quals = decl.decorators.select { |kw| CExtractorConstants::TYPE_QUALIFIER_KEYWORDS.include?(kw) }
+    quals.empty? ? '' : "#{quals.join(' ')} "
+  end
+
   # Emit a partial header file.
   #
   # Iterates c_module.element_sequence to emit non-function items (macros, typedefs,
@@ -101,13 +169,21 @@ class GeneratorPartials
     c_module.element_sequence.each do |item|
       case item
       when CExtractorTypes::CStatement
+        # Typedefs and aggregate definitions live in the shared types header generated by
+        # generate_types instead of here, so that content defines a type exactly once no
+        # matter how many of a module's generated headers end up in the same test file.
+        next if type_defining?(item, c_module)
         io << item.text << "\n"
         last_was_func = false
         anything_emitted = true
       when CExtractorTypes::CVariableDeclaration
         next unless include_variables
-        # If there is no array involved, array_suffix collapses to an empty string
-        io << "extern #{item.type} #{item.name}#{item.array_suffix};\n"
+        # If there is no array involved, array_suffix collapses to an empty string.
+        # A leading const/volatile/restrict on the original declaration (see
+        # qualifier_prefix) is part of the variable's type and belongs here too,
+        # so this extern agrees with the definition and any other declaration of
+        # the same variable elsewhere in the translation unit.
+        io << "extern #{qualifier_prefix(item)}#{item.type} #{item.name}#{item.array_suffix};\n"
         last_was_func = false
         anything_emitted = true
       when CExtractorTypes::CFunctionDefinition, CExtractorTypes::CFunctionDeclaration
@@ -170,7 +246,12 @@ class GeneratorPartials
     c_module.element_sequence.each do |item|
       case item
       when CExtractorTypes::CVariableDeclaration
-        io << "#{item.text}\n"
+        # `item.text` is the declaration with its leading decorator run removed (see
+        # CExtractorDeclarations#extract_decorators), so a const/volatile/restrict
+        # qualifier on the base type is reapplied here via qualifier_prefix -- this
+        # definition's type must match the extern declaration emitted for the same
+        # variable in generate_header.
+        io << "#{qualifier_prefix(item)}#{item.text}\n"
         last_was_func = false
         anything_emitted = true
       when CExtractorTypes::CFunctionDefinition