ceedling 1.0.1 → 1.1.0

data/lib/ceedling/build_batchinator.rb

@@ -1,113 +0,0 @@
-# =========================================================================
-#   Ceedling - Test-Centered Build System for C
-#   ThrowTheSwitch.org
-#   Copyright (c) 2010-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
-#   SPDX-License-Identifier: MIT
-# =========================================================================
-
-class BuildBatchinator
-
-  constructor :configurator, :loginator, :reportinator
-
-  def setup
-    @queue = Queue.new
-  end
-
-  # Neaten up a build step with progress message and some scope encapsulation
-  def build_step(msg, heading: true, &block)
-    if heading
-      msg = @reportinator.generate_heading( @loginator.decorate( msg, LogLabels::RUN ) )
-    else # Progress message
-      msg = "\n" + @reportinator.generate_progress( @loginator.decorate( msg, LogLabels::RUN ) )
-    end
-
-    @loginator.log( msg )
-
-    yield # Execute build step block
-  end
-
-  # Parallelize work to be done:
-  #  - Enqueue things (thread-safe)
-  #  - Spin up a number of worker threads within constraints of project file config and amount of work
-  #  - Each worker thread consumes one item from queue and runs the block against its details
-  #  - When the queue is empty, the worker threads wind down
-  def exec(workload:, things:, &block)
-    workers = 0
-
-    case workload
-    when :compile
-      workers = @configurator.project_compile_threads
-    when :test
-      workers = @configurator.project_test_threads
-    else
-      raise NameError.new("Unrecognized batch workload type: #{workload}")
-    end
-
-    # Enqueue all the items the block will execute against
-    things.each { |thing| @queue << thing }
-
-    # Choose lesser of max workers or number of things to process & redefine workers
-    # (It's neater and more efficient to avoid workers we won't use)
-    workers = [workers, things.size].min
-
-    threads = (1..workers).collect do
-      thread = Thread.new do
-        Thread.handle_interrupt(Exception => :never) do
-          begin
-            Thread.handle_interrupt(Exception => :immediate) do
-              # Run tasks until there are no more enqueued
-              loop do
-                # pop(true) is non-blocking and raises ThreadError when queue is empty
-                yield @queue.pop(true)
-              end
-            end
-
-          # First, handle thread exceptions (should always be due to empty queue)
-          rescue ThreadError => e
-            # Typical case: do nothing and allow thread to wind down
-
-            # ThreadError outside scope of expected empty queue condition
-            unless e.message.strip.casecmp("queue empty")
-              # Shutdown all worker threads
-              shutdown_threads(threads) 
-              # Raise exception again after intervening
-              raise(e)
-            end
-
-          # Second, catch every other kind of exception so we can intervene with thread cleanup.
-          # Generally speaking, catching Exception is a no-no, but we must in this case.
-          # Raise the exception again so that:
-          #  1. Calling code knows something bad happened and handles appropriately
-          #  2. Ruby runtime can handle most serious problems
-          rescue Exception => e
-            # Shutdown all worker threads
-            shutdown_threads(threads) 
-            # Raise exception again after intervening
-            raise(e)
-          end
-        end
-      end
-
-      # Hand thread to Enumerable collect() routine
-      thread.abort_on_exception = true
-      thread
-    end
-
-    # Hand worker threads to scheduler / wait for them to finish
-    threads.each { |thread| thread.join }
-  end
-
-  ### Private ###
-
-  private
-
-  # Terminate worker threads other than ourselves (we're already winding down)
-  def shutdown_threads(workers)
-    workers.each do |thread|
-      next if thread == Thread.current
-      thread.terminate
-    end
-  end
-
-end
-

data/lib/ceedling/generator_test_results_backtrace.rb

@@ -1,215 +0,0 @@
-# =========================================================================
-#   Ceedling - Test-Centered Build System for C
-#   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
-#   SPDX-License-Identifier: MIT
-# =========================================================================
-
-class GeneratorTestResultsBacktrace
-
-  constructor :configurator, :tool_executor, :generator_test_results
-
-  def setup()
-    @RESULTS_COLLECTOR = Struct.new( :passed, :failed, :ignored, :output, keyword_init:true )
-  end
-
-  def do_simple(filename, executable, shell_result, test_cases)
-    # Clean stats tracker
-    test_case_results = @RESULTS_COLLECTOR.new( passed:0, failed:0, ignored:0, output:[] )
-
-    # Reset time
-    shell_result[:time] = 0
-
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # Build the test fixture to run with our test case of interest
-      command = @tool_executor.build_command_line(
-        @configurator.tools_test_fixture_simple_backtrace, [],
-        executable,
-        test_case[:test]
-      )
-      # Things are gonna go boom, so ignore booms to get output
-      command[:options][:boom] = false
-
-      crash_result = @tool_executor.exec( command )
-
-      # Sum execution time for each test case
-      # Note: Running tests serpatately increases total execution time)
-      shell_result[:time] += crash_result[:time].to_f()
-
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
-
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
-
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
-
-      else # Crash failure case
-        test_case_results[:failed]  += 1
-        test_output = "#{filename}}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed"
-      end
-
-      # Collect up real and stand-in test results output
-      test_case_results[:output] << test_output
-    end
-
-    # Reset shell result exit code and output
-    shell_result[:exit_code] = test_case_results[:failed]
-    shell_result[:output] =
-      @generator_test_results.regenerate_test_executable_stdout(
-        total:   test_cases.size(),
-        ignored: test_case_results[:ignored],
-        failed:  test_case_results[:failed],
-        output:  test_case_results[:output]
-      )
-
-    return shell_result
-  end
-
-  def do_gdb(filename, executable, shell_result, test_cases)
-    gdb_script_filepath = File.join( @configurator.project_build_tests_root, BACKTRACE_GDB_SCRIPT_FILE )
-
-    # Clean stats tracker
-    test_case_results = @RESULTS_COLLECTOR.new( passed:0, failed:0, ignored:0, output:[] )
-
-    # Reset time
-    shell_result[:time] = 0
-
-    # Iterate on test cases
-    test_cases.each do |test_case|
-      # Build the test fixture to run with our test case of interest
-      command = @tool_executor.build_command_line(
-        @configurator.tools_test_backtrace_gdb, [],
-        gdb_script_filepath,
-        executable,
-        test_case[:test]
-      )
-      # Things are gonna go boom, so ignore booms to get output
-      command[:options][:boom] = false
-
-      crash_result = @tool_executor.exec( command )
-
-      # Sum execution time for each test case
-      # Note: Running tests serpatately increases total execution time)
-      shell_result[:time] += crash_result[:time].to_f()
-
-      test_output = ''
-
-      # Process single test case stats
-      case crash_result[:output]
-      # Success test case
-      when /(^#{filename}.+:PASS\s*$)/
-        test_case_results[:passed]  += 1
-        test_output = $1 # Grab regex match
-
-      # Ignored test case
-      when /(^#{filename}.+:IGNORE\s*$)/
-        test_case_results[:ignored] += 1
-        test_output = $1 # Grab regex match
-
-      when /(^#{filename}.+:FAIL(:.+)?\s*$)/
-        test_case_results[:failed]  += 1
-        test_output = $1 # Grab regex match
-
-      else # Crash failure case
-        test_case_results[:failed]  += 1
-
-        # Collect file_name and line in which crash occurred
-        matched = crash_result[:output].match( /#{test_case[:test]}\s*\(\)\sat.+#{filename}:(\d+)\n/ )
-
-        # If we found an error report line containing `test_case() at filename.c:###` in `gdb` output
-        if matched
-          # Line number
-          line_number = matched[1]
-
-          # Filter the `gdb` $stdout report to find most important lines of text
-          crash_report = filter_gdb_test_report( crash_result[:output], test_case[:test], filename )
-
-          # Unity’s test executable output is line oriented.
-          # Multi-line output is not possible (it looks like random `printf()` statements to the results parser)
-          # "Encode" newlines in multiline string to be handled by the test results parser.
-          test_output = crash_report.gsub( "\n", NEWLINE_TOKEN )
-
-          test_output = "#{filename}:#{line_number}:#{test_case[:test]}:FAIL: Test case crashed >> #{test_output}"
-
-        # Otherwise communicate that `gdb` failed to produce a usable report
-        else
-          test_output = "#{filename}:#{test_case[:line_number]}:#{test_case[:test]}:FAIL: Test case crashed (no usable `gdb` report)"
-        end
-      end
-
-      test_case_results[:output] << test_output
-    end
-
-    # Reset shell result exit code and output
-    shell_result[:exit_code] = test_case_results[:failed]
-    shell_result[:output] =
-      @generator_test_results.regenerate_test_executable_stdout(
-        total:   test_cases.size(),
-        ignored: test_case_results[:ignored],
-        failed:  test_case_results[:failed],
-        output:  test_case_results[:output]
-      )
-
-    return shell_result
-  end
-
-  ### Private ###
-  private
-
-  def filter_gdb_test_report(report, test_case, filename)
-    #       Sample `gdb` backtrace output
-    #       =============================
-    #       [Thread debugging using libthread_db enabled]
-    #       Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
-    #
-    # [1] > Program received signal SIGSEGV, Segmentation fault.
-    #       0x0000555999f661fb in testCrash () at test/TestUsartModel.c:40
-    # [2] > 40    uint32_t i = *nullptr;
-    #       #0  0x0000555999f661fb in testCrash () at test/TestUsartModel.c:40
-    #       #1  0x0000555999f674de in run_test (func=0x555999f661e7 <testCrash>, name=0x555999f6b2e0 "testCrash", line_num=37) at build/test/runners/TestUsartModel_runner.c:76
-    #       #2  0x0000555999f6766b in main (argc=3, argv=0x7fff917e2c98) at build/test/runners/TestUsartModel_runner.c:117
-
-    lines = report.split( "\n" )
-
-    # Safe defaults to extract entire report
-    report_start_index = 0                # [1]
-    report_end_index   = (lines.size()-1) # [2]
-
-    # Find line preceding last `<test_case> () at <filename>`, [2];
-    # it is the offending line of code.
-    # We don't need the rest of the call trace -- it's just from the runner 
-    # up to the crashed test case.
-    lines.each_with_index do |line, index|
-      if line =~ /#{test_case}.+at.+#{filename}/
-        report_end_index = (index - 1) unless (index == 0)
-      end
-    end
-
-    # Work up from [2] to find top line of the containing text block, [1].
-    # Go until we find a blank line; then increment index back down a line.
-    # This lops off any unneeded preamble.
-    report_end_index.downto(0).to_a().each do |index|
-      if lines[index].empty?
-        # Look for a blank line and adjust index to next line of text
-        report_start_index = (index + 1)
-        break
-      end
-    end
-
-    length = (report_end_index - report_start_index) + 1
-
-    # Reconstitute the report from the extracted lines
-    return lines[report_start_index, length].join( "\n" )
-  end
-
-end

data/lib/ceedling/generator_test_runner.rb

@@ -1,84 +0,0 @@
-# =========================================================================
-#   Ceedling - Test-Centered Build System for C
-#   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
-#   SPDX-License-Identifier: MIT
-# =========================================================================
-
-require 'generate_test_runner' # Unity's test runner generator
-
-class GeneratorTestRunner
-
-  attr_accessor :test_cases
-
-  #
-  # This class is not within any DIY context.
-  # It is instantiated on demand for each test file processed in a build.
-  #
-
-  def initialize(config:, test_file_contents:, preprocessed_file_contents:nil)
-    @unity_runner_generator = UnityTestRunnerGenerator.new( config )
-    
-    # Reduced information set
-    @test_cases = []
-
-    # Full information set used for runner generation
-    @test_cases_internal = []
-
-    parse_test_file( test_file_contents, preprocessed_file_contents )
-  end
-
-  def generate(module_name:, runner_filepath:, mock_list:, test_file_includes:, header_extension:)
-    # Actually build the test runner using Unity's test runner generator.
-    @unity_runner_generator.generate(
-      module_name,
-      runner_filepath,
-      @test_cases_internal,
-      mock_list.map{ |mock| mock + header_extension },
-      test_file_includes.map{|f| File.basename(f,'.*') + header_extension}
-    )
-  end
-
-  ### Private ###
-
-  private
-
-  def parse_test_file(test_file_contents, preprocessed_file_contents)
-    # If there's a preprocessed file, align test case line numbers with original file contents
-    if (!preprocessed_file_contents.nil?)
-      # Save the test case structure to be used in generation
-      @test_cases_internal = @unity_runner_generator.find_tests( preprocessed_file_contents )
-      
-      # Configure the runner generator around `setUp()` and `tearDown()`
-      @unity_runner_generator.find_setup_and_teardown( preprocessed_file_contents )
-
-      # Modify line numbers to match the original, non-preprocessed file
-      source_lines = test_file_contents.split("\n")
-      source_index = 0;
-      @test_cases_internal.size.times do |i|
-        source_lines[source_index..-1].each_with_index do |line, index|
-          if (line =~ /#{@test_cases_internal[i][:test]}/)
-            source_index += index
-            @test_cases_internal[i][:line_number] = source_index + 1
-            break
-          end
-        end
-      end
-
-    # Just look for the test cases within the original test file
-    else
-      # Save the test case structure to be used in generation
-      @test_cases_internal = @unity_runner_generator.find_tests( test_file_contents )
-
-      # Configure the runner generator around `setUp()` and `tearDown()`
-      @unity_runner_generator.find_setup_and_teardown( test_file_contents )
-    end
-
-    # Unity's `find_tests()` produces an array of hashes with the following keys...
-    # { test:, args:, call:, params:, line_number: }
-
-    # For external use of test case names and line numbers, keep only those pieces of info
-    @test_cases = @test_cases_internal.map {|hash| hash.slice( :test, :line_number )}
-  end
-
-end

data/lib/ceedling/preprocessinator.rb

@@ -1,239 +0,0 @@
-# =========================================================================
-#   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_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
-    # Aliases
-    @includes_handler = @preprocessinator_includes_handler
-    @file_handler = @preprocessinator_file_handler
-  end
-
-
-  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 = []
-
-    # 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 )
-
-      msg = "Loaded existing #include list from #{includes_list_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 )
-
-    # Full preprocessing-based #include extraction with saving to YAML file
-    else
-      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 includes
-  end
-
-
-  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_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
-
-  ### 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