ceedling 1.1.3 → 1.1.5

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

@@ -756,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

@@ -295,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,94 @@ 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
+      pending_macros = []
+
+      c_module.element_sequence.each do |item|
+        next unless item.is_a?(CExtractorTypes::CStatement)
+
+        if c_module.macro_definitions.include?(item)
+          pending_macros << item
+          next
+        end
+
+        next unless type_defining?(item, c_module)
+
+        # A typedef/struct/enum moved here may depend on a macro (e.g. an array-size
+        # constant) that preceded it in the original source -- this header is #included
+        # before any macro generate_header later emits inline into the non-shared
+        # header, so that macro would otherwise be undefined here. Carrying it forward
+        # is safe: an identical #define may legally repeat, so generate_header's own
+        # unmodified inline copy causes no redefinition conflict.
+        pending_macros.each { |macro| file << macro.text << "\n" }
+        pending_macros.clear
+
+        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 +188,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 +265,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