ceedling 1.0.1 → 1.1.0

data/lib/ceedling/flaginator.rb

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/lib/ceedling/{generator.rb → generators/generator.rb}

@@ -1,12 +1,13 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
 require 'ceedling/constants'
 require 'ceedling/exceptions'
+require 'ceedling/includes/includes'
 require 'ceedling/file_path_utils'
 require 'rake'
 
@@ -14,10 +15,10 @@ class Generator
 
   constructor :configurator,
               :generator_helper,
-              :preprocessinator,
               :generator_mocks,
               :generator_test_results,
               :generator_test_results_backtrace,
+              :generator_partials,
               :test_context_extractor,
               :tool_executor,
               :file_finder,
@@ -25,7 +26,6 @@ class Generator
               :reportinator,
               :loginator,
               :plugin_manager,
-              :file_wrapper,
               :test_runner_manager
 
 
@@ -35,6 +35,57 @@ class Generator
     @backtrace = @generator_test_results_backtrace
   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",
+      module_name: test,
+      filename: partial # Partial module name, not filename
+    )
+    @loginator.log( msg )
+
+    arg_hash = {
+      :test => test,
+      :name => partial,
+      :function_declarations => function_declarations,
+      :includes => includes,
+      :c_module => c_module,
+      :output_path => output_path
+    }
+
+    return @generator_partials.generate_interface( **arg_hash )
+  end
+
+  def generate_partial_implementation(
+      test:,
+      partial:,
+      function_definitions:,
+      source_includes:,
+      header_includes:,
+      c_module:,
+      input_filepath:,
+      output_path:
+    )
+
+    msg = @reportinator.generate_module_progress(
+      operation: "Generating Partial implementation for",
+      module_name: test,
+      filename: partial # Partial module name, not filename
+    )
+    @loginator.log( msg )
+
+    arg_hash = {
+      :function_definitions => function_definitions,
+      :test => test,
+      :name => partial,
+      :source_includes => source_includes,
+      :header_includes => header_includes,
+      :c_module => c_module,
+      :output_path => output_path
+    }
+
+    return @generator_partials.generate_implementation( **arg_hash )
+  end
+
   def generate_mock(context:, mock:, test:, input_filepath:, output_path:)
     arg_hash = {
       :header_file => input_filepath,
@@ -74,7 +125,9 @@ class Generator
     end
   end
 
-  def generate_test_runner(context:, mock_list:, includes_list:, test_filepath:, input_filepath:, runner_filepath:)
+  # @param mocks: Array of Mocks to include in the runner
+  # @param includes: Array of Includes without mocks to include in the runner
+  def generate_test_runner(context:, mocks:, includes:, test_filepath:, input_filepath:, runner_filepath:)
     arg_hash = {
       :context => context,
       :test_file => test_filepath,
@@ -97,14 +150,18 @@ class Generator
       raise CeedlingException.new( msg )
     end
 
+    # Further filter others to remove vendor files
+    others = includes.reject do |include|
+      VENDORS_FILES.include?( include.filename.ext() )
+    end
+
     # Build runner file
     begin
       unity_test_runner_generator.generate(
         module_name: module_name,
         runner_filepath: runner_filepath,
-        mock_list: mock_list,
-        test_file_includes: includes_list,
-        header_extension: @configurator.extension_header
+        mocks: mocks,
+        includes: others
       )
     rescue StandardError => ex
       # Re-raise execption but decorate it to better identify it in Ceedling output
@@ -156,7 +213,9 @@ class Generator
     command =
       @tool_executor.build_command_line(
         arg_hash[:tool],
+        # Extra arguments
         arg_hash[:flags],
+        # Argument replacement
         arg_hash[:source],
         arg_hash[:object],
         arg_hash[:list],
@@ -219,7 +278,9 @@ class Generator
     command =
       @tool_executor.build_command_line( 
         arg_hash[:tool],
+        # Extra arguments
         arg_hash[:flags],
+        # Argument replacement
         arg_hash[:source],
         arg_hash[:object],
         arg_hash[:search_paths],
@@ -260,7 +321,9 @@ class Generator
     command =
       @tool_executor.build_command_line(
         arg_hash[:tool],
+        # Extra arguments
         arg_hash[:flags],
+        # Argument replacement
         arg_hash[:objects],
         arg_hash[:executable],
         arg_hash[:map],
@@ -287,13 +350,13 @@ class Generator
       :test_name => test_name,
       :test_filepath => test_filepath,
       :executable => executable,
-      :result_file => result
+      :result_file => result,
+      :msg => @reportinator.generate_progress( "Running #{File.basename(executable)}" )
     }
 
     @plugin_manager.pre_test_fixture_execute( arg_hash )
 
-    msg = @reportinator.generate_progress( "Running #{File.basename(arg_hash[:executable])}" )
-    @loginator.log( msg )
+    @loginator.log( arg_hash[:msg] )
 
     # Unity's exit code is equivalent to the number of failed tests.
     # We tell @tool_executor not to fail out if there are failures
@@ -301,8 +364,9 @@ class Generator
     command = 
       @tool_executor.build_command_line(
         arg_hash[:tool],
-        # Apply additional test case filters 
+        # Extra arguments: Additional test case filters 
         @test_runner_manager.collect_cmdline_args(),
+        # Argument replacement
         arg_hash[:executable]
       )
 
@@ -311,7 +375,6 @@ class Generator
     # We'll analyze its results apart from tool_executor
     command[:options][:boom] = false
     shell_result = @tool_executor.exec( command )
-
     filename = File.basename( test_filepath )
 
     # Handle crashes
@@ -329,13 +392,13 @@ class Generator
       case @configurator.project_config_hash[:project_use_backtrace]
       # If we have the options and tools to learn more, dig into the details
       when :gdb
-        shell_result = 
-          @backtrace.do_gdb( filename, executable, shell_result, test_cases )
+        shell_result =
+          @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: context )
 
       # Simple test-case-by-test-case exercise
       when :simple
-        shell_result = 
-          @backtrace.do_simple( filename, executable, shell_result, test_cases )
+        shell_result =
+          @backtrace.do_simple( filename, executable, shell_result, test_cases, context: context )
 
       else # :none
         # Otherwise, call a crash a single failure so it shows up in the report
@@ -346,13 +409,11 @@ class Generator
         )
       end
     end
-
-    processed = @generator_test_results.process_and_write_results( 
-      executable,
-      shell_result,
-      arg_hash[:result_file],
-      @file_finder.find_test_file_from_filepath( arg_hash[:executable] )
-    )
+    
+    shell_result[:executable] = executable
+    shell_result[:result_file] = arg_hash[:result_file]
+    shell_result[:test_file] = @file_finder.find_test_file_from_filepath( arg_hash[:executable] )
+    processed = @generator_test_results.process_and_write_results( shell_result )
 
     arg_hash[:result_file]  = processed[:result_file]
     arg_hash[:results]      = processed[:results]
@@ -360,6 +421,8 @@ class Generator
     arg_hash[:shell_result] = shell_result
 
     @plugin_manager.post_test_fixture_execute( arg_hash )
+
+    shell_result
   end
 
 end

data/lib/ceedling/{generator_helper.rb → generators/generator_helper.rb}

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -21,7 +21,9 @@ class GeneratorHelper
     # Unix Signal 11 ==> SIGSEGV
     # Applies to Unix-like systems including MSYS on Windows
     if (shell_result[:status].termsig == 11)
-      @loginator.log( "#{runner} process terminated with SIGSEGV (Unix Signal 11)", Verbosity::DEBUG, LogLabels::CRASH )
+      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do 
+        "#{runner} process terminated with SIGSEGV (Unix Signal 11)"
+      end
       crash = true
     end
 
@@ -31,15 +33,19 @@ class GeneratorHelper
       crash = true
     end
 
-    # Negative lookahead regex that checks all lines in test STDERR output.
-    # (?m) enables multiline mode.
-    # Matches only a line with a 'segfault' variant that does not begin with the test code filename.
-    # Processing STDERR and ignoring lines that look like test case results helps limit false positives.
-    segfault_pattern = 'Seg.*fault'
-    regex = /\A(?!(?m).*^#{Regexp.escape(test_filename)}.*$).*(?:#{segfault_pattern})/mi
-  
-    if shell_result[:stderr].match?(regex)
-      @loginator.log( "#{runner} STDERR reports segmentation fault", Verbosity::DEBUG, LogLabels::CRASH )
+    # 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
+    # lines coexist in the same stderr output.
+    segfault_pattern = /Seg.*fault/i
+    bare_segfault = shell_result[:stderr].each_line.any? do |line|
+      line.match?(segfault_pattern) && !line.start_with?(test_filename)
+    end
+
+    if bare_segfault
+      @loginator.lazy( Verbosity::DEBUG, LogLabels::CRASH ) do
+        "#{runner} STDERR reports segmentation fault"
+      end
       crash = true
     end
 

data/lib/ceedling/{generator_mocks.rb → generators/generator_mocks.rb}

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/lib/ceedling/generators/generator_partials.rb

@@ -0,0 +1,177 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/file_wrapper'
+require 'ceedling/partials/partials'
+require 'ceedling/c_extractor/c_extractor_types'
+
+class GeneratorPartials
+
+  constructor :file_wrapper, :file_path_utils, :loginator
+
+  def generate_implementation(
+      test:,
+      name:,
+      function_definitions:,
+      source_includes:,
+      header_includes:,
+      c_module:,
+      output_path:
+    )
+    source = @file_path_utils.form_partial_implementation_source_filename(name)
+    header = @file_path_utils.form_partial_implementation_header_filename(name)
+
+    header_filepath = File.join(output_path, header)
+    source_filepath = File.join(output_path, source)
+
+    @file_wrapper.open(header_filepath, 'w') do |file|
+      generate_header(file, header, header_includes, function_definitions, c_module, true)
+    end
+
+    @file_wrapper.open(source_filepath, 'w') do |file|
+      generate_source(file, source_includes, function_definitions, c_module)
+    end
+
+    return source_filepath
+  end
+
+  def generate_interface(test:, name:, function_declarations:, includes:, c_module:, output_path:)
+    header = @file_path_utils.form_partial_interface_header_filename(name)
+    filepath = File.join(output_path, header)
+
+    @file_wrapper.open(filepath, 'w') do |file|
+      generate_header(file, header, includes, function_declarations, c_module, false)
+    end
+
+    return filepath
+  end
+
+  private
+
+  # Emit a partial header file.
+  #
+  # Iterates c_module.element_sequence to emit non-function items (macros, typedefs,
+  # aggregates, and optionally variable extern declarations) in their original extraction
+  # order. Function items in element_sequence are matched by name against function_list
+  # (pre-filtered Partials::FunctionDeclaration or Partials::FunctionDefinition objects)
+  # and emitted at their natural position. Any function_list entries not found in
+  # element_sequence (e.g., added from a different module) are emitted afterward.
+  #
+  # @param io              [IO]     Output file handle
+  # @param name            [String] Header filename (used for include guard)
+  # @param includes        [Array]  Include directives
+  # @param function_list   [Array]  Pre-filtered Partials function objects (respond to :name and :signature)
+  # @param c_module        [CExtractorTypes::CModule] Merged module with element_sequence
+  # @param include_variables [Boolean] True for implementation header (emits extern vars); false for interface
+  def generate_header(io, name, includes, function_list, c_module, include_variables)
+    guard = FileWrapper.generate_include_guard( name )
+
+    io << "#ifndef #{guard}\n"
+    io << "#define #{guard}\n\n"
+
+    includes.each do |include|
+      io << "#{include}\n"
+    end
+
+    io << "\n" if !includes.empty?
+
+    func_by_name = function_list.to_h { |f| [f.name, f] }
+    emitted_funcs = {}
+    last_was_func = false
+    anything_emitted = false
+
+    emit_func = lambda do |func|
+      # Blank line before a function when preceded by a non-function item
+      io << "\n" if anything_emitted && !last_was_func
+      io << func.signature << ";\n\n"
+      emitted_funcs[func.name] = true
+      last_was_func = true
+      anything_emitted = true
+    end
+
+    c_module.element_sequence.each do |item|
+      case item
+      when CExtractorTypes::CStatement
+        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"
+        last_was_func = false
+        anything_emitted = true
+      when CExtractorTypes::CFunctionDefinition, CExtractorTypes::CFunctionDeclaration
+        func = func_by_name[item.name]
+        next unless func && !emitted_funcs[item.name]
+        emit_func.call(func)
+      end
+    end
+
+    # Non-function items end with \n; add one more for a blank line before #endif.
+    # Function items already end with \n\n, so no extra newline needed.
+    io << "\n" if anything_emitted && !last_was_func
+
+    io << "#endif // #{guard}\n\n"
+  end
+
+  # Emit a partial source file.
+  #
+  # Iterates c_module.element_sequence to emit CVariableDeclaration and
+  # CFunctionDefinition items in their original extraction order. CStatement and
+  # CFunctionDeclaration items are skipped (they belong in headers). Function items
+  # are matched by name against function_definitions (pre-filtered
+  # Partials::FunctionDefinition objects). Any entries not found in element_sequence
+  # are emitted afterward.
+  #
+  # @param io                   [IO]     Output file handle
+  # @param includes             [Array]  Include directives
+  # @param function_definitions [Array]  Pre-filtered Partials::FunctionDefinition objects
+  # @param c_module             [CExtractorTypes::CModule] Merged module with element_sequence
+  def generate_source(io, includes, function_definitions, c_module)
+    io << "// Ceeding generated file\n"
+    includes.each do |include|
+      io << "#{include}\n"
+    end
+
+    io << "\n"
+
+    func_by_name = function_definitions.to_h { |f| [f.name, f] }
+    emitted_funcs = {}
+    last_was_func = false
+    anything_emitted = false
+
+    emit_func = lambda do |func|
+      # Blank line before a function when preceded by a non-function item
+      io << "\n" if anything_emitted && !last_was_func
+      if func.line_num and func.source_filepath
+        io << "#line #{func.line_num} \"#{func.source_filepath}\"\n"
+      end
+      io << func.code_block << "\n\n"
+      emitted_funcs[func.name] = true
+      last_was_func = true
+      anything_emitted = true
+    end
+
+    c_module.element_sequence.each do |item|
+      case item
+      when CExtractorTypes::CVariableDeclaration
+        io << "#{item.text}\n"
+        last_was_func = false
+        anything_emitted = true
+      when CExtractorTypes::CFunctionDefinition
+        func = func_by_name[item.name]
+        next unless func && !emitted_funcs[item.name]
+        emit_func.call(func)
+      end
+      # CStatement and CFunctionDeclaration items are skipped in source
+    end
+
+  end
+
+
+end

data/lib/ceedling/{generator_test_results.rb → generators/generator_test_results.rb}

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -87,15 +87,18 @@ require 'ceedling/exceptions'
 
 class GeneratorTestResults
 
-  constructor :configurator, :generator_test_results_sanity_checker, :yaml_wrapper
+  constructor :configurator, :generator_test_results_sanity_checker, :loginator, :reportinator, :yaml_wrapper
 
   def setup()
     # Aliases
     @sanity_checker = @generator_test_results_sanity_checker
   end
 
-  def process_and_write_results(executable, unity_shell_result, results_file, test_file)
-    output_file = results_file
+  def process_and_write_results(unity_shell_result)
+
+    executable  = unity_shell_result[:executable]
+    output_file = unity_shell_result[:result_file]
+    test_file   = unity_shell_result[:test_file]
 
     results = get_results_structure
 
@@ -104,56 +107,71 @@ class GeneratorTestResults
     results[:source][:file] = test_file
     results[:time] = unity_shell_result[:time] unless unity_shell_result[:time].nil?
 
+    # When Unity is built with UNITY_OUTPUT_COLOR, ANSI escape sequences wrap
+    # test-result tokens and the summary result token, e.g.:
+    #   test_foo.c:24:test_bar:\e[0;32mPASS\e[0m
+    #   test_foo.c:39:test_baz:\e[0;31mFAIL\e[0m: Expected 2 Was 3
+    #   ---------\n2 Tests 0 Failures 0 Ignored\n\e[0;32mOK\e[0m
+    # Strip them up front so that all downstream regex anchors and literal
+    # tokens (including TEST_STDOUT_STATISTICS) work correctly.
+    raw_output = unity_shell_result[:output].gsub(/\e\[[\d;]*[mK]/, '')
+
     # Process test statistics
-    if (unity_shell_result[:output] =~ PATTERNS::TEST_STDOUT_STATISTICS)
+    if (raw_output =~ PATTERNS::TEST_STDOUT_STATISTICS)
       results[:counts][:total] =   $1.to_i
       results[:counts][:failed] =  $2.to_i
       results[:counts][:ignored] = $3.to_i
       results[:counts][:passed] = (results[:counts][:total] - results[:counts][:failed] - results[:counts][:ignored])
     else
-      raise CeedlingException.new( "Could not parse output for `#{executable}`: \"#{unity_shell_result[:output]}\"" ) 
+      raise CeedlingException.new( "Could not parse output for `#{executable}` ⏩️ \"#{unity_shell_result[:output]}\"" )
     end
 
     # Remove test statistics lines
-    output_string = unity_shell_result[:output].sub( PATTERNS::TEST_STDOUT_STATISTICS, '' )
+    output_string = raw_output.sub( PATTERNS::TEST_STDOUT_STATISTICS, '' )
 
     # Process test executable results line-by-line
     output_string.lines do |line|
       # Process Unity test executable output
-      case line.chomp
+      chomped_line = line.chomp
+      case chomped_line
       when /(:IGNORE)/
         elements = extract_line_elements( executable, line, results[:source][:file] )
         results[:ignores] << elements[0] 
-        results[:stdout] << elements[1] if (!elements[1].nil?)
+        results[:stdout] << elements[1] unless (elements[1].nil? || elements[1].empty?)
 
       when /(:PASS$)/
         elements = extract_line_elements( executable, line, results[:source][:file] )
         results[:successes] << elements[0] 
-        results[:stdout] << elements[1] if (!elements[1].nil?)
+        results[:stdout] << elements[1] unless (elements[1].nil? || elements[1].empty?)
 
       when /(:PASS \(.* ms\)$)/
         elements = extract_line_elements( executable, line, results[:source][:file] )
         results[:successes] << elements[0] 
-        results[:stdout] << elements[1] if (!elements[1].nil?)
+        results[:stdout] << elements[1] unless (elements[1].nil? || elements[1].empty?)
 
       when /(:FAIL)/
         elements = extract_line_elements( executable, line, results[:source][:file] )
         results[:failures] << elements[0]
-        results[:stdout] << elements[1] if (!elements[1].nil?)
+        results[:stdout] << elements[1] unless (elements[1].nil? || elements[1].empty?)
 
       # Collect up all other output
       else
-        results[:stdout] << line.chomp # Ignores blank lines
+        results[:stdout] << chomped_line unless chomped_line.empty?
       end
     end
 
+    @loginator.log("Test results from #{File.basename(executable)} => #{results}", Verbosity::DEBUG)
+
     @sanity_checker.verify( results, unity_shell_result[:exit_code] )
 
-    output_file = results_file.ext( @configurator.extension_testfail ) if (results[:counts][:failed] > 0)
+    output_file = output_file.ext( @configurator.extension_testfail ) if (results[:counts][:failed] > 0)
+
+    msg = @reportinator.generate_progress("Collecting test results from #{File.basename(executable)} to #{output_file}")
+    @loginator.log(msg, Verbosity::OBNOXIOUS)
 
     @yaml_wrapper.dump(output_file, results)
 
-    return { :result_file => output_file, :result => results }
+    return { :result_file => output_file, :results => results }
   end
 
   # Filter list of test cases:
@@ -166,12 +184,20 @@ class GeneratorTestResults
 
     # Filter tests which contain test_case_name passed by `--test_case` argument
     if !@configurator.include_test_case.empty?
-      _test_cases.delete_if { |i| !(i[:test] =~ /#{@configurator.include_test_case}/) }
+      begin
+        _test_cases.delete_if { |i| !(i[:test] =~ /#{@configurator.include_test_case}/) }
+      rescue RegexpError => e
+        raise CeedlingException.new( "Invalid --test_case regex '#{@configurator.include_test_case}': #{e.message}" )
+      end
     end
 
     # Filter tests which contain test_case_name passed by `--exclude_test_case` argument
     if !@configurator.exclude_test_case.empty?
-      _test_cases.delete_if { |i| i[:test] =~ /#{@configurator.exclude_test_case}/ }
+      begin
+        _test_cases.delete_if { |i| i[:test] =~ /#{@configurator.exclude_test_case}/ }
+      rescue RegexpError => e
+        raise CeedlingException.new( "Invalid --exclude_test_case regex '#{@configurator.exclude_test_case}': #{e.message}" )
+      end
     end
 
     return _test_cases