ceedling 0.31.1 → 1.0.1

data/lib/ceedling/plugin_reportinator.rb

@@ -1,5 +1,13 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'ceedling/constants'
 require 'ceedling/defaults'
+require 'ceedling/exceptions'
 
 class PluginReportinator
   
@@ -9,25 +17,74 @@ class PluginReportinator
     @test_results_template = nil
   end
   
-  
+  def register_test_results_template(template)
+    @test_results_template = template
+  end
+
   def set_system_objects(system_objects)
     @plugin_reportinator_helper.ceedling = system_objects
   end
   
-  
   def fetch_results(results_path, test, options={:boom => false})
     return @plugin_reportinator_helper.fetch_results( File.join(results_path, test), options )
   end
 
-  
   def generate_banner(message)
     return @reportinator.generate_banner(message)
   end
 
-  
+  def generate_heading(message)
+    return @reportinator.generate_heading(message)
+  end
+
+  ##
+  ## Sample Test Results Output File (YAML)
+  ## ======================================
+  ##
+  ## TestUsartModel.fail:
+  ## ---
+  ## :source:
+  ##   :file: test/TestUsartModel.c
+  ##   :dirname: test
+  ##   :basename: TestUsartModel.c
+  ## :successes:
+  ## - :test: testGetBaudRateRegisterSettingShouldReturnAppropriateBaudRateRegisterSetting
+  ##   :line: 24
+  ##   :message: ''
+  ##   :unity_test_time: 0
+  ## - :test: testGetFormattedTemperatureFormatsTemperatureFromCalculatorAppropriately
+  ##   :line: 49
+  ##   :message: ''
+  ##   :unity_test_time: 0
+  ## - :test: testShouldReturnErrorMessageUponInvalidTemperatureValue
+  ##   :line: 55
+  ##   :message: ''
+  ##   :unity_test_time: 0
+  ## - :test: testShouldReturnWakeupMessage
+  ##   :line: 61
+  ##   :message: ''
+  ##   :unity_test_time: 0
+  ## :failures:
+  ## - :test: testFail
+  ##   :line: 39
+  ##   :message: Expected 2 Was 3
+  ##   :unity_test_time: 0
+  ## :ignores:
+  ## - :test: testIgnore
+  ##   :line: 34
+  ##   :message: ''
+  ##   :unity_test_time: 0
+  ## :counts:
+  ##   :total: 6
+  ##   :passed: 4
+  ##   :failed: 1
+  ##   :ignored: 1
+  ## :stdout: []
+  ## :time: 0.006512000225484371
+
   def assemble_test_results(results_list, options={:boom => false})
-    aggregated_results = get_results_structure
-    
+    aggregated_results = new_results()
+
     results_list.each do |result_path| 
       results = @plugin_reportinator_helper.fetch_results( result_path, options )
       @plugin_reportinator_helper.process_results(aggregated_results, results)
@@ -35,41 +92,47 @@ class PluginReportinator
 
     return aggregated_results
   end
-  
-  
-  def register_test_results_template(template)
-    @test_results_template = template if (@test_results_template.nil?)
-  end
-  
-  
+      
   def run_test_results_report(hash, verbosity=Verbosity::NORMAL, &block)
-    run_report( $stdout,
-                ((@test_results_template.nil?) ? DEFAULT_TESTS_RESULTS_REPORT_TEMPLATE : @test_results_template),
-                hash,
-                verbosity,
-                &block )
+    if @test_results_template.nil?
+      raise CeedlingException.new( "No test results report template has been set." )
+    end
+
+    run_report(
+      @test_results_template,
+      hash,
+      verbosity,
+      &block
+    )
   end
   
-  
-  def run_report(stream, template, hash=nil, verbosity=Verbosity::NORMAL)
+  def run_report(template, hash=nil, verbosity=Verbosity::NORMAL)
     failure = nil
     failure = yield() if block_given?
   
     @plugin_manager.register_build_failure( failure )
-    
-    @plugin_reportinator_helper.run_report( stream, template, hash, verbosity )
+  
+    # Set verbosity to error level if there were failures
+    verbosity = failure ? Verbosity::ERRORS : Verbosity::NORMAL
+
+    @plugin_reportinator_helper.run_report( template, hash, verbosity )
   end
   
-  private ###############################
+  #
+  # Private
+  #
+
+  private
   
-  def get_results_structure
+  def new_results()
     return {
-      :successes => [],
-      :failures  => [],
-      :ignores   => [],
-      :stdout    => [],
-      :counts    => {:total => 0, :passed => 0, :failed => 0, :ignored  => 0, :stdout => 0},
-      :time      => 0.0
+      :times       => {},
+      :successes   => [],
+      :failures    => [],
+      :ignores     => [],
+      :stdout      => [],
+      :counts      => {:total => 0, :passed => 0, :failed => 0, :ignored  => 0, :stdout => 0},
+      :total_time  => 0.0
       }
   end
  

data/lib/ceedling/plugin_reportinator_helper.rb

@@ -1,51 +1,84 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'erb'
 require 'rubygems'
 require 'rake' # for ext()
 require 'ceedling/constants'
+require 'ceedling/exceptions'
 
 class PluginReportinatorHelper
   
   attr_writer :ceedling
   
-  constructor :configurator, :streaminator, :yaml_wrapper, :file_wrapper
+  constructor :configurator, :loginator, :yaml_wrapper, :file_wrapper
   
   def fetch_results(results_path, options)
-    pass_path = File.join(results_path.ext( @configurator.extension_testpass ))
-    fail_path = File.join(results_path.ext( @configurator.extension_testfail ))
-
-    if (@file_wrapper.exist?(fail_path))
-      return @yaml_wrapper.load(fail_path)
-    elsif (@file_wrapper.exist?(pass_path))
-      return @yaml_wrapper.load(pass_path)
-    else
-      if (options[:boom])
-        @streaminator.stderr_puts("Could find no test results for '#{File.basename(results_path).ext(@configurator.extension_source)}'", Verbosity::ERRORS)
-        raise
+    # Create the results filepaths
+    pass_path = results_path.ext( @configurator.extension_testpass )
+    fail_path = results_path.ext( @configurator.extension_testfail )
+
+    # Collect whether the results file(s) exists
+    pass_exists = ( @file_wrapper.exist?( pass_path ) ? true : false )
+    fail_exists = ( @file_wrapper.exist?( fail_path ) ? true : false )
+
+    # Handle if neither file exists
+    if !fail_exists and !pass_exists
+
+      if options[:boom]
+        # Complain loudly
+        error = "Could find no test results for '#{File.basename(results_path).ext(@configurator.extension_source)}'"
+        raise CeedlingException.new(error)
+
+      else
+        # Otherwise simply return empty results
+        return {}
       end
     end
+
+    # Handle if both files exists and return the newer results
+    if pass_exists and fail_exists
+      if @file_wrapper.newer?( pass_path, fail_path )
+        return @yaml_wrapper.load( pass_path )
+      else
+        return @yaml_wrapper.load( fail_path )
+      end
+    end
+
+    # Return success results
+    return @yaml_wrapper.load(pass_path) if pass_exists
+
+    # Return fail results
+    return @yaml_wrapper.load(fail_path) if fail_exists
     
+    # Safety fall-through (flow control should never get here)
     return {}
   end
 
-
-  def process_results(aggregate_results, results)
+  def process_results(aggregate, results)
     return if (results.empty?)
-    aggregate_results[:successes]        << { :source => results[:source].clone, :collection => results[:successes].clone } if (results[:successes].size > 0)
-    aggregate_results[:failures]         << { :source => results[:source].clone, :collection => results[:failures].clone  } if (results[:failures].size > 0)
-    aggregate_results[:ignores]          << { :source => results[:source].clone, :collection => results[:ignores].clone   } if (results[:ignores].size > 0)
-    aggregate_results[:stdout]           << { :source => results[:source].clone, :collection => results[:stdout].clone    } if (results[:stdout].size > 0)
-    aggregate_results[:counts][:total]   += results[:counts][:total]
-    aggregate_results[:counts][:passed]  += results[:counts][:passed]
-    aggregate_results[:counts][:failed]  += results[:counts][:failed]
-    aggregate_results[:counts][:ignored] += results[:counts][:ignored]
-    aggregate_results[:counts][:stdout]  += results[:stdout].size
-    aggregate_results[:time] += results[:time]
+    aggregate[:times][(results[:source][:file])] = results[:time]
+    aggregate[:successes]        << { :source => results[:source].clone, :collection => results[:successes].clone } if (results[:successes].size > 0)
+    aggregate[:failures]         << { :source => results[:source].clone, :collection => results[:failures].clone  } if (results[:failures].size > 0)
+    aggregate[:ignores]          << { :source => results[:source].clone, :collection => results[:ignores].clone   } if (results[:ignores].size > 0)
+    aggregate[:stdout]           << { :source => results[:source].clone, :collection => results[:stdout].clone    } if (results[:stdout].size > 0)
+    aggregate[:counts][:total]   += results[:counts][:total]
+    aggregate[:counts][:passed]  += results[:counts][:passed]
+    aggregate[:counts][:failed]  += results[:counts][:failed]
+    aggregate[:counts][:ignored] += results[:counts][:ignored]
+    aggregate[:counts][:stdout]  += results[:stdout].size
+    aggregate[:total_time]       += results[:time]
   end
 
+  def run_report(template, hash, verbosity)
+    output = ERB.new( template, trim_mode: "%<>" )
 
-  def run_report(stream, template, hash, verbosity)
-    output = ERB.new(template, 0, "%<>")
-    @streaminator.stream_puts(stream, output.result(binding()), verbosity)
+    # Run the report template and log result with no log level heading
+    @loginator.log( output.result(binding()), verbosity, LogLabels::NONE )
   end
   
 end

data/lib/ceedling/preprocessinator.rb

@@ -1,56 +1,239 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class Preprocessinator
 
-  constructor :preprocessinator_helper, :preprocessinator_includes_handler, :preprocessinator_file_handler, :task_invoker, :file_path_utils, :yaml_wrapper, :project_config_manager, :configurator
+  constructor :preprocessinator_includes_handler,
+              :preprocessinator_file_handler,
+              :task_invoker,
+              :file_finder,
+              :file_path_utils,
+              :file_wrapper,
+              :yaml_wrapper,
+              :plugin_manager,
+              :configurator,
+              :test_context_extractor,
+              :loginator,
+              :reportinator,
+              :rake_wrapper
 
 
   def setup
-    # fashion ourselves callbacks @preprocessinator_helper can use
-    @preprocess_includes_proc  = Proc.new { |filepath| self.preprocess_shallow_includes(filepath) }
-    @preprocess_mock_file_proc = Proc.new { |filepath| self.preprocess_file(filepath) }
-    @preprocess_test_file_directives_proc = Proc.new { |filepath| self.preprocess_file_directives(filepath) }
-    @preprocess_test_file_proc = Proc.new { |filepath| self.preprocess_file(filepath) }
+    # Aliases
+    @includes_handler = @preprocessinator_includes_handler
+    @file_handler = @preprocessinator_file_handler
   end
 
-  def preprocess_shallow_source_includes(test)
-    @preprocessinator_helper.preprocess_source_includes(test)
-  end
 
-  def preprocess_test_and_invoke_test_mocks(test)
-    @preprocessinator_helper.preprocess_includes(test, @preprocess_includes_proc)
+  def preprocess_includes(filepath:, test:, flags:, include_paths:, defines:, deep: false)
+    includes_list_filepath = @file_path_utils.form_preprocessed_includes_list_filepath( filepath, test )
+
+    includes = []
 
-    mocks_list = @preprocessinator_helper.assemble_mocks_list(test)
+    # If existing YAML file of includes is newer than the file we're processing, skip preprocessing
+    if @file_wrapper.newer?( includes_list_filepath, filepath )
+      msg = @reportinator.generate_module_progress(
+        operation: "Loading #include statement listing file for",
+        module_name: test,
+        filename: File.basename(filepath)
+        )
+      @loginator.log( msg, Verbosity::NORMAL )
+      
+      # Note: It's possible empty YAML content returns nil
+      includes = @yaml_wrapper.load( includes_list_filepath )
 
-    @project_config_manager.process_test_defines_change(mocks_list)
+      msg = "Loaded existing #include list from #{includes_list_filepath}:"
 
-    @preprocessinator_helper.preprocess_mockable_headers(mocks_list, @preprocess_mock_file_proc)
+      if includes.nil? or includes.empty?
+        # Ensure includes defaults to emtpy array to prevent external iteration problems
+        includes = []
+        msg += ' <empty>'
+      else
+        includes.each { |include| msg += "\n - #{include}" }
+      end
 
-    @task_invoker.invoke_test_mocks(mocks_list)
+      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.log( '', Verbosity::DEBUG )
 
-    if (@configurator.project_use_preprocessor_directives)
-      @preprocessinator_helper.preprocess_test_file(test, @preprocess_test_file_directives_proc)
+    # Full preprocessing-based #include extraction with saving to YAML file
     else
-      @preprocessinator_helper.preprocess_test_file(test, @preprocess_test_file_proc)
+      includes = @includes_handler.extract_includes(
+        filepath:      filepath,
+        test:          test,
+        flags:         flags,
+        include_paths: include_paths,
+        defines:       defines,
+        deep:          deep
+        )
+
+      msg = "Extracted #include list from #{filepath}:"
+
+      if includes.nil? or includes.empty?
+        # Ensure includes defaults to emtpy array to prevent external iteration problems
+        includes = []
+        msg += ' <empty>'
+      else
+        includes.each { |include| msg += "\n - #{include}" }
+      end
+
+      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.log( '', Verbosity::DEBUG )
+      
+      @includes_handler.write_includes_list( includes_list_filepath, includes )
     end
 
-    return mocks_list
+    return includes
   end
 
-  def preprocess_shallow_includes(filepath)
-    includes = @preprocessinator_includes_handler.extract_includes(filepath)
 
-    @preprocessinator_includes_handler.write_shallow_includes_list(
-      @file_path_utils.form_preprocessed_includes_list_filepath(filepath), includes)
+  def preprocess_mockable_header_file(filepath:, test:, flags:, include_paths:, defines:)
+    preprocessed_filepath = @file_path_utils.form_preprocessed_file_filepath( filepath, test )
+
+    # Check if we're using deep define processing for mocks
+    preprocess_deep = !@configurator.project_use_deep_preprocessor.nil? && [:mocks, :all].include?(@configurator.project_use_deep_preprocessor)
+
+    plugin_arg_hash = {
+      header_file:              filepath,
+      preprocessed_header_file: preprocessed_filepath,
+      test:                     test,
+      flags:                    flags,
+      include_paths:            include_paths,
+      defines:                  defines      
+    }
+
+    # Trigger pre_mock_preprocessing plugin hook
+    @plugin_manager.pre_mock_preprocess( plugin_arg_hash )
+
+    arg_hash = {
+      filepath:       filepath,
+      test:           test,
+      flags:          flags,
+      include_paths:  include_paths,
+      defines:        defines,
+      deep:           preprocess_deep     
+    }
+
+    # Extract includes & log progress and details   
+    includes = preprocess_file_common( **arg_hash )
+
+    arg_hash = {
+      source_filepath:       filepath,
+      test:                  test,
+      flags:                 flags,
+      include_paths:         include_paths,
+      defines:               defines,
+      extras:                (@configurator.cmock_treat_inlines == :include)
+    }
+
+    # `contents` & `extras` are arrays of text strings to be assembled in generating a new header file.
+    # `extras` are macro definitions, pragmas, etc. needed for the special case of mocking `inline` function declarations.
+    # `extras` are empty for any cases other than mocking `inline` function declarations
+    #  (We don't want to increase our chances of a badly generated file--extracting extras could fail in complex files.)
+    contents, extras = @file_handler.collect_header_file_contents( **arg_hash )
+
+    arg_hash = {
+      filename:              File.basename( filepath ),
+      preprocessed_filepath: preprocessed_filepath,
+      contents:              contents,
+      extras:                extras,
+      includes:              includes                       
+    }
+
+    # Create a reconstituted header file from preprocessing expansion and preserving any extras
+    @file_handler.assemble_preprocessed_header_file( **arg_hash )
+
+    # Trigger post_mock_preprocessing plugin hook
+    @plugin_manager.post_mock_preprocess( plugin_arg_hash )
+
+    return preprocessed_filepath
   end
 
-  def preprocess_file(filepath)
-    @preprocessinator_includes_handler.invoke_shallow_includes_list(filepath)
-    @preprocessinator_file_handler.preprocess_file( filepath, @yaml_wrapper.load(@file_path_utils.form_preprocessed_includes_list_filepath(filepath)) )
+
+  def preprocess_test_file(filepath:, test:, flags:, include_paths:, defines:)
+    preprocessed_filepath = @file_path_utils.form_preprocessed_file_filepath( filepath, test )
+
+    # Check if we're using deep define processing for mocks
+    preprocess_deep = !@configurator.project_use_deep_preprocessor.nil? && [:tests, :all].include?(@configurator.project_use_deep_preprocessor)
+
+    plugin_arg_hash = {
+      test_file:              filepath,
+      preprocessed_test_file: preprocessed_filepath,
+      test:                   test,
+      flags:                  flags,
+      include_paths:          include_paths,
+      defines:                defines      
+    }
+
+    # Trigger pre_test_preprocess plugin hook
+    @plugin_manager.pre_test_preprocess( plugin_arg_hash )
+
+    arg_hash = {
+      filepath:      filepath,
+      test:          test,
+      flags:         flags,
+      include_paths: include_paths,
+      defines:       defines,
+      deep:          preprocess_deep      
+    }
+
+    # Extract includes & log progress and info
+    includes = preprocess_file_common( **arg_hash )
+
+    arg_hash = {
+      source_filepath:       filepath,
+      test:                  test,
+      flags:                 flags,
+      include_paths:         include_paths,
+      defines:               defines      
+    }
+
+    # `contents` & `extras` are arrays of text strings to be assembled in generating a new test file.
+    # `extras` are test build directives TEST_SOURCE_FILE() and TEST_INCLUDE_PATH().
+    contents, extras = @file_handler.collect_test_file_contents( **arg_hash )
+
+    arg_hash = {
+      filename:              File.basename( filepath ),
+      preprocessed_filepath: preprocessed_filepath,
+      contents:              contents,
+      extras:                extras,
+      includes:              includes                       
+    }
+
+    # Create a reconstituted test file from preprocessing expansion and preserving any extras
+    @file_handler.assemble_preprocessed_test_file( **arg_hash )
+
+    # Trigger pre_mock_preprocessing plugin hook
+    @plugin_manager.post_test_preprocess( plugin_arg_hash )
+
+    return preprocessed_filepath
   end
 
-  def preprocess_file_directives(filepath)
-    @preprocessinator_includes_handler.invoke_shallow_includes_list( filepath )
-    @preprocessinator_file_handler.preprocess_file_directives( filepath,
-      @yaml_wrapper.load( @file_path_utils.form_preprocessed_includes_list_filepath( filepath ) ) )
+  ### Private ###
+  private
+
+  def preprocess_file_common(filepath:, test:, flags:, include_paths:, defines:, deep: false)
+    msg = @reportinator.generate_module_progress(
+      operation: "Preprocessing",
+      module_name: test,
+      filename: File.basename(filepath)
+    )
+
+    @loginator.log( msg, Verbosity::NORMAL )
+
+    # Extract includes
+    includes = preprocess_includes(
+      filepath:      filepath,
+      test:          test,
+      flags:         flags,
+      include_paths: include_paths,
+      defines:       defines,
+      deep:          deep) 
+
+    return includes
   end
+
 end