ceedling 0.31.1 → 1.0.1

data/lib/ceedling/flaginator.rb

@@ -1,74 +1,65 @@
-require 'rubygems'
-require 'rake' # for ext()
-require 'fileutils'
-require 'ceedling/constants'
-
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 # :flags:
-#   :release:
+#   :test:
 #     :compile:
-#       :'test_.+'
-#         - -pedantic   # add '-pedantic' to every test file
-#       :*:          # add '-foo' to compilation of all files not main.c
+#       :*:                       # Add '-foo' to compilation of all files for all test executables
 #         - -foo
-#       :main:       # add '-Wall' to compilation of main.c
+#       :Model:                   # Add '-Wall' to compilation of any test executable with Model in its filename
 #         - -Wall
-#   :test:
 #     :link:
-#       :test_main:  # add '--bar --baz' to linking of test_main.exe
+#       :tests/comm/TestUsart.c:  # Add '--bar --baz' to link step of TestUsart executable
 #         - --bar
 #         - --baz
+#   :release:
+#     - -std=c99
 
-def partition(hash, &predicate)
-  hash.partition(&predicate).map(&:to_h)
-end
+# :flags:
+#   :test:
+#     :compile:                   # Equivalent to [test][compile]['*'] -- i.e. same extra flags for all test executables
+#       - -foo
+#       - -Wall
+#     :link:                      # Equivalent to [test][link]['*'] -- i.e. same flags for all test executables
+#       - --bar
+#       - --baz
 
 class Flaginator
 
-  constructor :configurator
+  constructor :configurator, :loginator, :config_matchinator
 
-  def get_flag(hash, file_name)
-    file_key = file_name.to_sym
-   
-    # 1. try literals
-    literals, magic = partition(hash) { |k, v| k.to_s =~ /^\w+$/ }  
-    return literals[file_key] if literals.include?(file_key)
-    
-    any, regex = partition(magic) { |k, v| (k == :'*') || (k == :'.*')  } # glob or regex wild card
-    
-    # 2. try regexes
-    find_res = regex.find { |k, v| file_name =~ /^#{k.to_s}$/ }
-    return find_res[1] if find_res
-    
-    # 3. try anything
-    find_res = any.find { |k, v| file_name =~ /.*/ }
-    return find_res[1] if find_res
-      
-    # 4. well, we've tried
-    return []
+  def setup
+    @section = :flags
   end
-  
-  def flag_down( operation, context, file )
-    # create configurator accessor method
-    accessor = ('flags_' + context.to_s).to_sym
 
-    # create simple filename key from whatever filename provided
-    file_name = File.basename( file ).ext('')
-    file_key = File.basename( file ).ext('').to_sym
-
-    # if no entry in configuration for flags for this context, bail out
-    return [] if not @configurator.respond_to?( accessor )
+  def flags_defined?(context:, operation:nil)
+    return @config_matchinator.config_include?(primary:@section, secondary:context, tertiary:operation)
+  end
 
-    # get flags sub hash associated with this context
-    flags = @configurator.send( accessor )
+  def flag_down(context:, operation:, filepath:nil, default:[])
+    flags = @config_matchinator.get_config(primary:@section, secondary:context, tertiary:operation)
 
-    # if operation not represented in flags hash, bail out
-    return [] if not flags.include?( operation )
+    if flags == nil then return default
+    # Flatten to handle list-nested YAML aliasing (should have already been flattened during validation)
+    elsif flags.is_a?(Array) then return flags.flatten
+    elsif flags.is_a?(Hash)
+      arg_hash = {
+        hash: flags,
+        filepath: filepath,
+        section: @section,
+        context: context,
+        operation: operation
+      }
 
-    # redefine flags to sub hash associated with the operation
-    flags = flags[operation]
+      return @config_matchinator.matches?(**arg_hash)
+    end
 
-    return get_flag(flags, file_name)
+    # Handle unexpected config element type
+    return []
   end
 
 end

data/lib/ceedling/generator.rb

@@ -1,103 +1,236 @@
+# =========================================================================
+#   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/exceptions'
+require 'ceedling/file_path_utils'
+require 'rake'
 
 class Generator
 
   constructor :configurator,
               :generator_helper,
               :preprocessinator,
-              :cmock_builder,
-              :generator_test_runner,
+              :generator_mocks,
               :generator_test_results,
-              :flaginator,
-              :test_includes_extractor,
+              :generator_test_results_backtrace,
+              :test_context_extractor,
               :tool_executor,
               :file_finder,
               :file_path_utils,
-              :streaminator,
+              :reportinator,
+              :loginator,
               :plugin_manager,
-              :file_wrapper
+              :file_wrapper,
+              :test_runner_manager
 
 
-  def generate_shallow_includes_list(context, file)
-    @streaminator.stdout_puts("Generating include list for #{File.basename(file)}...", Verbosity::NORMAL)
-    @preprocessinator.preprocess_shallow_includes(file)
+  def setup()
+    # Aliases
+    @helper = @generator_helper
+    @backtrace = @generator_test_results_backtrace
   end
 
-  def generate_preprocessed_file(context, file)
-    @streaminator.stdout_puts("Preprocessing #{File.basename(file)}...", Verbosity::NORMAL)
-    @preprocessinator.preprocess_file(file)
+  def generate_mock(context:, mock:, test:, input_filepath:, output_path:)
+    arg_hash = {
+      :header_file => input_filepath,
+      :test => test,
+      :context => context,
+      :output_path => output_path }
+    
+    @plugin_manager.pre_mock_generate( arg_hash )
+
+    begin
+      # Below is a workaround that instantiates CMock anew:
+      #  1. To allow dfferent output path per mock
+      #  2. To avoid any thread safety complications
+
+      # TODO:
+      #  - Add option to CMock to generate mock to any destination path
+      #  - Make CMock thread-safe
+
+      # Get default config created by Ceedling and customize it
+      config = @generator_mocks.build_configuration( output_path )
+  
+      # Generate mock
+      msg = @reportinator.generate_module_progress(
+        operation: "Generating mock for",
+        module_name: test,
+        filename: File.basename(input_filepath)
+      )
+      @loginator.log( msg )
+
+      cmock = @generator_mocks.manufacture( config )
+      cmock.setup_mocks( arg_hash[:header_file] )
+    rescue StandardError => ex
+      # Re-raise execption but decorate it with CMock to better identify it
+      raise( ex, "CMock >> #{ex.message}", ex.backtrace )
+    ensure
+      @plugin_manager.post_mock_generate( arg_hash )
+    end
   end
 
-  def generate_dependencies_file(tool, context, source, object, dependencies)
-    @streaminator.stdout_puts("Generating dependencies for #{File.basename(source)}...", Verbosity::NORMAL)
+  def generate_test_runner(context:, mock_list:, includes_list:, test_filepath:, input_filepath:, runner_filepath:)
+    arg_hash = {
+      :context => context,
+      :test_file => test_filepath,
+      :input_file => input_filepath,
+      :runner_file => runner_filepath}
 
-    command =
-      @tool_executor.build_command_line(
-        tool,
-        [], # extra per-file command line parameters
-        source,
-        dependencies,
-        object)
+    @plugin_manager.pre_runner_generate( arg_hash )
 
-    @tool_executor.exec( command[:line], command[:options] )
-  end
+    # Collect info we need
+    module_name = File.basename( arg_hash[:test_file] )
 
-  def generate_mock(context, header_filepath)
-    arg_hash = {:header_file => header_filepath, :context => context}
-    @plugin_manager.pre_mock_generate( arg_hash )
+    msg = @reportinator.generate_progress("Generating runner for #{module_name}")
+    @loginator.log( msg )
+
+    unity_test_runner_generator = 
+      @test_context_extractor.lookup_test_runner_generator( test_filepath )
 
+    if unity_test_runner_generator.nil?
+      msg = "Could not find test runner generator for #{test_filepath}"
+      raise CeedlingException.new( msg )
+    end
+
+    # Build runner file
     begin
-      @cmock_builder.cmock.setup_mocks( arg_hash[:header_file] )
-    rescue
-      raise
+      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
+      )
+    rescue StandardError => ex
+      # Re-raise execption but decorate it to better identify it in Ceedling output
+      raise( ex, "Unity Runner Generator >> #{ex.message}", ex.backtrace )
     ensure
-      @plugin_manager.post_mock_generate( arg_hash )
+      @plugin_manager.post_runner_generate(arg_hash)
     end
   end
 
-  # test_filepath may be either preprocessed test file or original test file
-  def generate_test_runner(context, test_filepath, runner_filepath)
-    arg_hash = {:context => context, :test_file => test_filepath, :runner_file => runner_filepath}
-    @plugin_manager.pre_runner_generate(arg_hash)
+  def generate_object_file_c(
+      tool:,
+      module_name:,
+      context:,
+      source:,
+      object:,
+      search_paths:[],
+      flags:[],
+      defines:[],
+      list:'',
+      dependencies:'',
+      msg:nil
+    )
+
+    shell_result = {}
+    arg_hash = { :tool => tool,
+                 :module_name => module_name,
+                 :operation => OPERATION_COMPILE_SYM,
+                 :context => context,
+                 :source => source,
+                 :object => object,
+                 :search_paths => search_paths,
+                 :flags => flags,
+                 :defines => defines,
+                 :list => list,
+                 :dependencies => dependencies,
+                 :msg => String(msg)
+               }
 
-    # collect info we need
-    module_name = File.basename(arg_hash[:test_file])
-    test_cases  = @generator_test_runner.find_test_cases( @file_finder.find_test_from_runner_path(runner_filepath) )
-    mock_list   = @test_includes_extractor.lookup_raw_mock_list(arg_hash[:test_file])
+    @plugin_manager.pre_compile_execute(arg_hash)
 
-    @streaminator.stdout_puts("Generating runner for #{module_name}...", Verbosity::NORMAL)
+    msg = arg_hash[:msg]
+    msg = @reportinator.generate_module_progress(
+      operation: "Compiling",
+      module_name: module_name,
+      filename: File.basename(arg_hash[:source])
+      ) if msg.empty?
+    @loginator.log( msg )
 
-    test_file_includes = [] # Empty list for now, since apparently unused
+    command =
+      @tool_executor.build_command_line(
+        arg_hash[:tool],
+        arg_hash[:flags],
+        arg_hash[:source],
+        arg_hash[:object],
+        arg_hash[:list],
+        arg_hash[:dependencies],
+        arg_hash[:search_paths],
+        arg_hash[:defines]
+      )
 
-    # build runner file
     begin
-      @generator_test_runner.generate(module_name, runner_filepath, test_cases, mock_list, test_file_includes)
-    rescue
-      raise
+      shell_result = @tool_executor.exec( command )
+    rescue ShellException => ex
+      shell_result = ex.shell_result
+      raise ex
     ensure
-      @plugin_manager.post_runner_generate(arg_hash)
+      arg_hash[:shell_command] = command[:line]
+      arg_hash[:shell_result] = shell_result
+      @plugin_manager.post_compile_execute(arg_hash)
     end
   end
 
-  def generate_object_file(tool, operation, context, source, object, list='', dependencies='')
+  def generate_object_file_asm(
+      tool:,
+      module_name:,
+      context:,
+      source:,
+      object:,
+      search_paths:[],
+      flags:[],
+      defines:[],
+      list:'',
+      dependencies:'',
+      msg:nil
+    )
+
     shell_result = {}
-    arg_hash = {:tool => tool, :operation => operation, :context => context, :source => source, :object => object, :list => list, :dependencies => dependencies}
+
+    arg_hash = { :tool => tool,
+                 :module_name => module_name,
+                 :operation => OPERATION_ASSEMBLE_SYM,
+                 :context => context,
+                 :source => source,
+                 :object => object,
+                 :search_paths => search_paths,
+                 :flags => flags,
+                 :defines => defines,
+                 :list => list,
+                 :dependencies => dependencies
+               }
+
     @plugin_manager.pre_compile_execute(arg_hash)
 
-    @streaminator.stdout_puts("Compiling #{File.basename(arg_hash[:source])}...", Verbosity::NORMAL)
-    command =
-      @tool_executor.build_command_line( arg_hash[:tool],
-                                         @flaginator.flag_down( operation, context, source ),
-                                         arg_hash[:source],
-                                         arg_hash[:object],
-                                         arg_hash[:list],
-                                         arg_hash[:dependencies])
+    msg = String(msg)
+    msg = @reportinator.generate_module_progress(
+      operation: "Assembling",
+      module_name: module_name,
+      filename: File.basename(arg_hash[:source])
+      ) if msg.empty?
+    @loginator.log( msg )
 
-    @streaminator.stdout_puts("Command: #{command}", Verbosity::DEBUG)
+    command =
+      @tool_executor.build_command_line( 
+        arg_hash[:tool],
+        arg_hash[:flags],
+        arg_hash[:source],
+        arg_hash[:object],
+        arg_hash[:search_paths],
+        arg_hash[:defines],
+        arg_hash[:list],
+        arg_hash[:dependencies]
+      )
 
     begin
-      shell_result = @tool_executor.exec( command[:line], command[:options] )
-    rescue ShellExecutionException => ex
+      shell_result = @tool_executor.exec( command )
+    rescue ShellException => ex
       shell_result = ex.shell_result
       raise ex
     ensure
@@ -107,11 +240,12 @@ class Generator
     end
   end
 
-  def generate_executable_file(tool, context, objects, executable, map='', libraries=[], libpaths=[])
+  def generate_executable_file(tool, context, objects, flags, executable, map='', libraries=[], libpaths=[])
     shell_result = {}
     arg_hash = { :tool => tool,
                  :context => context,
                  :objects => objects,
+                 :flags => flags,
                  :executable => executable,
                  :map => map,
                  :libraries => libraries,
@@ -120,67 +254,112 @@ class Generator
 
     @plugin_manager.pre_link_execute(arg_hash)
 
-    @streaminator.stdout_puts("Linking #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
+    msg = @reportinator.generate_progress("Linking #{File.basename(arg_hash[:executable])}")
+    @loginator.log( msg )
+
     command =
-      @tool_executor.build_command_line( arg_hash[:tool],
-                                         @flaginator.flag_down( OPERATION_LINK_SYM, context, executable ),
-                                         arg_hash[:objects],
-                                         arg_hash[:executable],
-                                         arg_hash[:map],
-                                         arg_hash[:libraries],
-                                         arg_hash[:libpaths]
-                                       )
-    @streaminator.stdout_puts("Command: #{command}", Verbosity::DEBUG)
+      @tool_executor.build_command_line(
+        arg_hash[:tool],
+        arg_hash[:flags],
+        arg_hash[:objects],
+        arg_hash[:executable],
+        arg_hash[:map],
+        arg_hash[:libraries],
+        arg_hash[:libpaths]
+      )
 
     begin
-      shell_result = @tool_executor.exec( command[:line], command[:options] )
-    rescue ShellExecutionException => ex
-      notice =    "\n" +
-                  "NOTICE: If the linker reports missing symbols, the following may be to blame:\n" +
-                  "  1. Test lacks #include statements corresponding to needed source files.\n" +
-                  "  2. Project search paths do not contain source files corresponding to #include statements in the test.\n"
-
-      if (@configurator.project_use_mocks)
-        notice += "  3. Test does not #include needed mocks.\n\n"
-      else
-        notice += "\n"
-      end
-
-      @streaminator.stderr_puts(notice, Verbosity::COMPLAIN)
+      shell_result = @tool_executor.exec( command )
+    rescue ShellException => ex
       shell_result = ex.shell_result
-      raise ''
+      raise ex
     ensure
+      arg_hash[:shell_command] = command[:line]
       arg_hash[:shell_result] = shell_result
       @plugin_manager.post_link_execute(arg_hash)
     end
   end
 
-  def generate_test_results(tool, context, executable, result)
-    arg_hash = {:tool => tool, :context => context, :executable => executable, :result_file => result}
-    @plugin_manager.pre_test_fixture_execute(arg_hash)
-
-    @streaminator.stdout_puts("Running #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
-
-    # Unity's exit code is equivalent to the number of failed tests, so we tell @tool_executor not to fail out if there are failures
-    # so that we can run all tests and collect all results
-    command = @tool_executor.build_command_line(arg_hash[:tool], [], arg_hash[:executable])
-    @streaminator.stdout_puts("Command: #{command}", Verbosity::DEBUG)
+  def generate_test_results(tool:, context:, test_name:, test_filepath:, executable:, result:)
+    arg_hash = {
+      :tool => tool,
+      :context => context,
+      :test_name => test_name,
+      :test_filepath => test_filepath,
+      :executable => executable,
+      :result_file => result
+    }
+
+    @plugin_manager.pre_test_fixture_execute( arg_hash )
+
+    msg = @reportinator.generate_progress( "Running #{File.basename(arg_hash[:executable])}" )
+    @loginator.log( 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
+    # so that we can run all tests and collect all results.
+    command = 
+      @tool_executor.build_command_line(
+        arg_hash[:tool],
+        # Apply additional test case filters 
+        @test_runner_manager.collect_cmdline_args(),
+        arg_hash[:executable]
+      )
+
+    # Run the test executable itself
+    # We allow it to fail without an exception.
+    # We'll analyze its results apart from tool_executor
     command[:options][:boom] = false
-    shell_result = @tool_executor.exec( command[:line], command[:options] )
-
-    #Don't Let The Failure Count Make Us Believe Things Aren't Working
-    shell_result[:exit_code] = 0
-    @generator_helper.test_results_error_handler(executable, shell_result)
+    shell_result = @tool_executor.exec( command )
+
+    filename = File.basename( test_filepath )
+
+    # Handle crashes
+    if @helper.test_crash?( filename, executable, shell_result )
+      @helper.log_test_results_crash(
+        executable,
+        shell_result,
+        @configurator.project_config_hash[:project_use_backtrace]
+      )
+
+      # Lookup test cases and filter based on any matchers specified for the build task
+      test_cases = @test_context_extractor.lookup_test_cases( test_filepath )
+      test_cases = @generator_test_results.filter_test_cases( test_cases )
+
+      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 )
+
+      # Simple test-case-by-test-case exercise
+      when :simple
+        shell_result = 
+          @backtrace.do_simple( filename, executable, shell_result, test_cases )
+
+      else # :none
+        # Otherwise, call a crash a single failure so it shows up in the report
+        shell_result = @generator_test_results.create_crash_failure(
+          filename,
+          shell_result,
+          test_cases
+        )
+      end
+    end
 
-    processed = @generator_test_results.process_and_write_results( shell_result,
-                                                                   arg_hash[:result_file],
-                                                                   @file_finder.find_test_from_file_path(arg_hash[:executable]) )
+    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] )
+    )
 
     arg_hash[:result_file]  = processed[:result_file]
     arg_hash[:results]      = processed[:results]
-    arg_hash[:shell_result] = shell_result # for raw output display if no plugins for formatted display
+    # For raw output display if no plugins enabled for nice display
+    arg_hash[:shell_result] = shell_result
 
-    @plugin_manager.post_test_fixture_execute(arg_hash)
+    @plugin_manager.post_test_fixture_execute( arg_hash )
   end
 
 end