ceedling 0.0.1

data/new_project_template/vendor/ceedling/lib/file_path_utils.rb

@@ -0,0 +1,177 @@
+require 'rubygems'
+require 'rake' # for ext()
+require 'fileutils'
+require 'system_wrapper'
+
+# global utility methods (for plugins, project files, etc.)
+def ceedling_form_filepath(destination_path, original_filepath, new_extension=nil)
+  filename = File.basename(original_filepath)
+  filename.replace(filename.ext(new_extension)) if (!new_extension.nil?)
+  return File.join( destination_path.gsub(/\\/, '/'), filename )
+end
+
+class FilePathUtils
+
+  GLOB_MATCHER = /[\*\?\{\}\[\]]/
+
+  constructor :configurator, :file_wrapper
+
+
+  ######### class methods ##########
+
+  # standardize path to use '/' path separator & begin with './' & have no trailing path separator
+  def self.standardize(path)
+    path.strip!
+    path.gsub!(/\\/, '/')
+    path.gsub!(/^((\+|-):)?\.\//, '')
+    path.chomp!('/')
+    return path
+  end
+
+  def self.os_executable_ext(executable)
+    return executable.ext('.exe') if SystemWrapper.is_windows?
+    return executable
+  end
+
+  # extract directory path from between optional add/subtract aggregation modifiers and up to glob specifiers
+  # note: slightly different than File.dirname in that /files/foo remains /files/foo and does not become /files
+  def self.extract_path(path)
+    path = path.sub(/^(\+|-):/, '')
+    
+    # find first occurrence of path separator followed by directory glob specifier: *, ?, {, }, [, ]
+    find_index = (path =~ GLOB_MATCHER)
+    
+    # no changes needed (lop off final path separator)
+    return path.chomp('/') if (find_index.nil?)
+    
+    # extract up to first glob specifier
+    path = path[0..(find_index-1)]
+    
+    # lop off everything up to and including final path separator
+    find_index = path.rindex('/')
+    return path[0..(find_index-1)] if (not find_index.nil?)
+    
+    # return string up to first glob specifier if no path separator found
+    return path
+  end
+
+  # return whether the given path is to be aggregated (no aggregation modifier defaults to same as +:)
+  def self.add_path?(path)
+    return (path =~ /^-:/).nil?
+  end
+  
+  # get path (and glob) lopping off optional +: / -: prefixed aggregation modifiers
+  def self.extract_path_no_aggregation_operators(path)
+    return path.sub(/^(\+|-):/, '')
+  end
+  
+  # all the globs that may be in a path string work fine with one exception;
+  # to recurse through all subdirectories, the glob is dir/**/** but our paths use
+  # convention of only dir/**
+  def self.reform_glob(path)
+    return path if (path =~ /\/\*\*$/).nil?
+    return path + '/**'
+  end
+
+  def self.form_ceedling_vendor_path(*filepaths)
+    return File.join( CEEDLING_VENDOR, filepaths )
+  end
+
+  ######### instance methods ##########
+
+  def form_temp_path(filepath, prefix='')
+    return File.join( @configurator.project_temp_path, prefix + File.basename(filepath) )    
+  end
+  
+  ### release ###
+  def form_release_build_cache_path(filepath)
+    return File.join( @configurator.project_release_build_cache_path, File.basename(filepath) )    
+  end
+  
+  def form_release_dependencies_filepath(filepath)
+    return File.join( @configurator.project_release_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
+  end
+  
+  def form_release_build_c_object_filepath(filepath)
+    return File.join( @configurator.project_release_build_output_c_path, File.basename(filepath).ext(@configurator.extension_object) )
+  end
+
+  def form_release_build_asm_object_filepath(filepath)
+    return File.join( @configurator.project_release_build_output_asm_path, File.basename(filepath).ext(@configurator.extension_object) )
+  end
+
+  def form_release_build_c_objects_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_c_path}/%n#{@configurator.extension_object}")
+  end
+
+  def form_release_build_asm_objects_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_asm_path}/%n#{@configurator.extension_object}")
+  end
+  
+  def form_release_dependencies_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_dependencies_path}/%n#{@configurator.extension_dependencies}")
+  end
+  
+  ### tests ###
+  def form_test_build_cache_path(filepath)
+    return File.join( @configurator.project_test_build_cache_path, File.basename(filepath) )    
+  end
+  
+  def form_pass_results_filepath(filepath)
+    return File.join( @configurator.project_test_results_path, File.basename(filepath).ext(@configurator.extension_testpass) )
+  end
+
+  def form_fail_results_filepath(filepath)
+    return File.join( @configurator.project_test_results_path, File.basename(filepath).ext(@configurator.extension_testfail) )
+  end
+
+  def form_runner_filepath_from_test(filepath)
+    return File.join( @configurator.project_test_runners_path, File.basename(filepath, @configurator.extension_source)) + @configurator.test_runner_file_suffix + @configurator.extension_source
+  end
+
+  def form_test_filepath_from_runner(filepath)
+    return filepath.sub(/#{TEST_RUNNER_FILE_SUFFIX}/, '')
+  end
+
+  def form_runner_object_filepath_from_test(filepath)
+    return (form_test_build_object_filepath(filepath)).sub(/(#{@configurator.extension_object})$/, "#{@configurator.test_runner_file_suffix}\\1")
+  end
+
+  def form_test_build_object_filepath(filepath)
+    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_object) )
+  end
+
+  def form_test_executable_filepath(filepath)
+    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_executable) )    
+  end
+
+  def form_preprocessed_file_filepath(filepath)
+    return File.join( @configurator.project_test_preprocess_files_path, File.basename(filepath) )    
+  end
+
+  def form_preprocessed_includes_list_filepath(filepath)
+    return File.join( @configurator.project_test_preprocess_includes_path, File.basename(filepath) )    
+  end
+
+  def form_test_build_objects_filelist(sources)
+    return (@file_wrapper.instantiate_file_list(sources)).pathmap("#{@configurator.project_test_build_output_path}/%n#{@configurator.extension_object}")
+  end
+  
+  def form_preprocessed_mockable_headers_filelist(mocks)
+    # pathmapping note: "%{#{@configurator.cmock_mock_prefix},}n" replaces mock_prefix with nothing (signified by absence of anything after comma inside replacement brackets)
+    return (@file_wrapper.instantiate_file_list(mocks)).pathmap("#{@configurator.project_test_preprocess_files_path}/%{#{@configurator.cmock_mock_prefix},}n#{@configurator.extension_header}")
+  end
+
+  def form_mocks_source_filelist(mocks)
+    return (@file_wrapper.instantiate_file_list(mocks)).pathmap("#{@configurator.cmock_mock_path}/%n#{@configurator.extension_source}")
+  end
+
+  def form_test_dependencies_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_test_dependencies_path}/%n#{@configurator.extension_dependencies}")    
+  end
+
+  def form_pass_results_filelist(path, files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{path}/%n#{@configurator.extension_testpass}")    
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/file_system_utils.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+require 'set'
+require 'fileutils'
+require 'file_path_utils.rb'
+
+
+class FileSystemUtils
+  
+  constructor :file_wrapper
+
+  # build up path list from input of one or more strings or arrays of (+/-) paths & globs
+  def collect_paths(*paths)
+    raw   = []  # all paths and globs
+    plus  = Set.new # all paths to expand and add
+    minus = Set.new # all paths to remove from plus set
+    
+    # assemble all globs and simple paths, reforming our glob notation to ruby globs
+    paths.each do |paths_container|
+      case (paths_container)
+        when String then raw << (FilePathUtils::reform_glob(paths_container))
+        when Array  then paths_container.each {|path| raw << (FilePathUtils::reform_glob(path))}
+        else raise "Don't know how to handle #{paths_container.class}"
+      end
+    end
+
+    # iterate through each path and glob
+    raw.each do |path|
+    
+      dirs = []  # container for only (expanded) paths
+    
+      # if a glob, expand it and slurp up all non-file paths
+      if path.include?('*')
+        # grab base directory only if globs are snug up to final path separator
+        if (path =~ /\/\*+$/)
+          dirs << FilePathUtils.extract_path(path)
+        end
+        
+        # grab expanded sub-directory globs
+        expanded = @file_wrapper.directory_listing( FilePathUtils.extract_path_no_aggregation_operators(path) )
+        expanded.each do |entry|
+          dirs << entry if @file_wrapper.directory?(entry)
+        end
+        
+      # else just grab simple path
+      # note: we could just run this through glob expansion but such an
+      #       approach doesn't handle a path not yet on disk)
+      else
+        dirs << FilePathUtils.extract_path_no_aggregation_operators(path)
+      end
+      
+      # add dirs to the appropriate set based on path aggregation modifier if present
+      FilePathUtils.add_path?(path) ? plus.merge(dirs) : minus.merge(dirs)
+    end
+
+    return (plus - minus).to_a.uniq
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/file_wrapper.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'rake' # for FileList
+require 'constants'
+require 'fileutils'
+
+
+class FileWrapper
+
+  def get_expanded_path(path)
+    return File.expand_path(path)
+  end
+
+  def exist?(filepath)
+    return true if (filepath == NULL_FILE_PATH)
+    return File.exist?(filepath)
+  end
+
+  def directory?(path)
+    return File.directory?(path)
+  end
+
+  def dirname(path)
+    return File.dirname(path)
+  end
+
+  def directory_listing(glob)
+    return Dir.glob(glob)
+  end
+
+  def rm_f(filepath, options={})
+    FileUtils.rm_f(filepath, options)
+  end
+
+  def rm_r(filepath, options={})
+    FileUtils.rm_r(filepath, options={})
+  end
+  
+  def cp(source, destination, options={})
+    FileUtils.cp(source, destination, options)
+  end
+
+  def compare(from, to)
+    return FileUtils.compare_file(from, to)
+  end
+  
+  def open(filepath, flags)
+    File.open(filepath, flags) do |file|
+      yield(file)
+    end
+  end
+
+  def read(filepath)
+    return File.read(filepath)
+  end
+
+  def touch(filepath, options={})
+    FileUtils.touch(filepath, options)
+  end
+
+  def write(filepath, contents, flags='w')
+    File.open(filepath, flags) do |file|
+      file.write(contents)
+    end    
+  end
+
+  def readlines(filepath)
+    return File.readlines(filepath)
+  end
+
+  def instantiate_file_list(files=[])
+    return FileList.new(files)
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/generator.rb

@@ -0,0 +1,131 @@
+require 'constants' # for Verbosity constants class
+
+
+class Generator
+
+  constructor :configurator, :preprocessinator, :cmock_builder, :generator_test_runner, :generator_test_results, :test_includes_extractor, :tool_executor, :file_finder, :file_path_utils, :streaminator, :plugin_manager, :file_wrapper
+
+
+  def generate_shallow_includes_list(context, file)
+    @preprocessinator.preprocess_shallow_includes(file)
+  end
+
+  def generate_preprocessed_file(context, file)
+    @streaminator.stdout_puts("Preprocessing #{File.basename(file)}...", Verbosity::NORMAL)
+    @preprocessinator.preprocess_file(file)
+  end
+
+  def generate_dependencies_file(tool, context, source, object, dependencies)
+    @streaminator.stdout_puts("Generating dependencies for #{File.basename(source)}...", Verbosity::NORMAL)
+    
+    command_line = 
+      @tool_executor.build_command_line(
+        tool,
+        source,
+        dependencies,
+        object)
+    
+    @tool_executor.exec(command_line)
+  end
+
+  def generate_mock(context, header_filepath)
+    arg_hash = {:header_file => header_filepath, :context => context}
+    @plugin_manager.pre_mock_execute(arg_hash)
+    
+    @cmock_builder.cmock.setup_mocks( arg_hash[:header_file] )
+
+    @plugin_manager.post_mock_execute(arg_hash)
+  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_execute(arg_hash)
+    
+    # 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])
+
+    @streaminator.stdout_puts("Generating runner for #{module_name}...", Verbosity::NORMAL)
+    
+    # build runner file
+    @file_wrapper.open(runner_filepath, 'w') do |output|
+      @generator_test_runner.create_header(output, mock_list)
+      @generator_test_runner.create_externs(output, test_cases)
+      @generator_test_runner.create_mock_management(output, mock_list)
+      @generator_test_runner.create_runtest(output, mock_list, test_cases)
+      @generator_test_runner.create_main(output, module_name, test_cases)
+    end
+
+    @plugin_manager.post_runner_execute(arg_hash)
+  end
+
+  def generate_object_file(tool, context, source, object)    
+    arg_hash = {:tool => tool, :context => context, :source => source, :object => object}
+    @plugin_manager.pre_compile_execute(arg_hash)
+
+    @streaminator.stdout_puts("Compiling #{File.basename(arg_hash[:source])}...", Verbosity::NORMAL)
+    shell_result = @tool_executor.exec( @tool_executor.build_command_line(arg_hash[:tool], arg_hash[:source], arg_hash[:object]) )
+
+    arg_hash[:shell_result] = shell_result
+    @plugin_manager.post_compile_execute(arg_hash)
+  end
+
+  def generate_executable_file(tool, context, objects, executable)
+    shell_result = {}
+    arg_hash = {:tool => tool, :context => context, :objects => objects, :executable => executable}
+    @plugin_manager.pre_link_execute(arg_hash)
+    
+    @streaminator.stdout_puts("Linking #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
+    
+    begin
+      shell_result = @tool_executor.exec( @tool_executor.build_command_line(arg_hash[:tool], arg_hash[:objects], arg_hash[:executable]) )
+    rescue
+      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)
+      raise
+    end
+    
+    arg_hash[:shell_result] = shell_result
+    @plugin_manager.post_link_execute(arg_hash)
+  end
+
+  def generate_test_results(tool, context, executable, result)
+    arg_hash = {:tool => tool, :context => context, :executable => executable, :result_file => result}
+    @plugin_manager.pre_test_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
+    shell_result = @tool_executor.exec( @tool_executor.build_command_line(arg_hash[:tool], arg_hash[:executable]), [], {:boom => false} )
+    
+    if (shell_result[:output].nil? or shell_result[:output].strip.empty?)
+      @streaminator.stderr_puts("ERROR: Test executable \"#{File.basename(executable)}\" did not produce any results.", Verbosity::ERRORS)
+      raise
+    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]) )
+    
+    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
+    
+    @plugin_manager.post_test_execute(arg_hash)
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/generator_test_results.rb

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'rake' # for .ext()
+require 'constants'
+
+ 
+class GeneratorTestResults
+  TEST_STATISTICS_REGEX = /-+\s+(\d+)\s+Tests\s+(\d+)\s+Failures\s+(\d+)\s+Ignored\s+(OK|FAIL)\s*/i
+
+  constructor :configurator, :generator_test_results_sanity_checker, :yaml_wrapper
+ 
+  def process_and_write_results(unity_shell_result, results_file, test_file)
+    output_file = results_file
+    
+    results = get_results_structure
+    
+    results[:source][:path] = File.dirname(test_file)
+    results[:source][:file] = File.basename(test_file)
+    
+    # process test statistics
+    if (unity_shell_result[:output] =~ TEST_STATISTICS_REGEX)
+      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])
+    end
+
+    # remove test statistics lines
+    unity_shell_result[:output].sub!(TEST_STATISTICS_REGEX, '')
+    
+    # bust up the output into individual lines
+    raw_unity_lines = unity_shell_result[:output].split(/\n|\r\n/)
+    
+    raw_unity_lines.each do |line|
+      # process unity output
+      case line
+      when /(:IGNORE)/
+        elements = extract_line_elements(line, results[:source][:file])
+        results[:ignores]   << elements[0]
+        results[:stdout]    << elements[1] if (!elements[1].nil?)
+      when /(:PASS$)/
+        elements = extract_line_elements(line, results[:source][:file])
+        results[:successes] << elements[0]
+        results[:stdout]    << elements[1] if (!elements[1].nil?)
+      when /(:FAIL)/
+        elements = extract_line_elements(line, results[:source][:file])
+        results[:failures]  << elements[0]
+        results[:stdout]    << elements[1] if (!elements[1].nil?)
+      else # collect up all other
+        results[:stdout] << line.chomp
+      end
+    end
+    
+    @generator_test_results_sanity_checker.verify(results, unity_shell_result[:exit_code])
+    
+    output_file = results_file.ext(@configurator.extension_testfail) if (results[:counts][:failed] > 0)
+    
+    @yaml_wrapper.dump(output_file, results)
+    
+    return { :result_file => output_file, :result => results }
+  end
+
+  private
+
+  def get_results_structure
+    return {
+      :source    => {:path => '', :file => ''},
+      :successes => [],
+      :failures  => [],
+      :ignores   => [],
+      :counts    => {:total => 0, :passed => 0, :failed => 0, :ignored  => 0},
+      :stdout    => [],
+      }
+  end
+  
+  def extract_line_elements(line, filename)
+    # handle anything preceding filename in line as extra output to be collected
+    stdout = nil
+    stdout_regex = /(.+)#{Regexp.escape(filename)}.+/i
+    
+    if (line =~ stdout_regex)
+      stdout = $1.clone
+      line.sub!(/#{Regexp.escape(stdout)}/, '')
+    end
+    
+    # collect up test results minus and extra output
+    elements = (line.strip.split(':'))[1..-1]
+    return {:test => elements[1], :line => elements[0].to_i, :message => (elements[3..-1].join(':')).strip}, stdout
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/generator_test_results_sanity_checker.rb

@@ -0,0 +1,62 @@
+require 'constants'
+require 'rubygems'
+require 'rake' # for ext() method
+
+
+class GeneratorTestResultsSanityChecker
+
+  constructor :configurator, :streaminator
+  
+  def verify(results, unity_exit_code)
+  
+    # do no sanity checking if it's disabled
+    return if (@configurator.sanity_checks == TestResultsSanityChecks::NONE)
+  
+    ceedling_ignores_count   = results[:ignores].size
+    ceedling_failures_count  = results[:failures].size
+    ceedling_tests_summation = (ceedling_ignores_count + ceedling_failures_count + results[:successes].size)
+
+    # Exit code handling is not a sanity check that can always be performed because 
+    # command line simulators may or may not pass through Unity's exit code
+    if (@configurator.sanity_checks >= TestResultsSanityChecks::THOROUGH)
+      # many platforms limit exit codes to a maximum of 255
+      if ((ceedling_failures_count != unity_exit_code) and (unity_exit_code < 255))
+        sanity_check_warning(results[:source][:file], "Unity's exit code (#{unity_exit_code}) does not match Ceedling's summation of failed test cases (#{ceedling_failures_count}).")
+      end
+      
+      if ((ceedling_failures_count < 255) and (unity_exit_code == 255))
+        sanity_check_warning(results[:source][:file], "Ceedling's summation of failed test cases (#{ceedling_failures_count}) is less than Unity's exit code (255 or more).")
+      end
+    end
+    
+    if (ceedling_ignores_count != results[:counts][:ignored])
+      sanity_check_warning(results[:source][:file], "Unity's final ignore count (#{results[:counts][:ignored]}) does not match Ceedling's summation of ignored test cases (#{ceedling_ignores_count}).")
+    end
+    
+    if (ceedling_failures_count != results[:counts][:failed])
+      sanity_check_warning(results[:source][:file], "Unity's final fail count (#{results[:counts][:failed]}) does not match Ceedling's summation of failed test cases (#{ceedling_failures_count}).")
+    end
+
+    if (ceedling_tests_summation != results[:counts][:total])
+      sanity_check_warning(results[:source][:file], "Unity's final test count (#{results[:counts][:total]}) does not match Ceedling's summation of all test cases (#{ceedling_tests_summation}).")
+    end
+    
+  end
+
+  private
+  
+  def sanity_check_warning(file, message)
+    notice = "\n" + 
+             "ERROR: Internal sanity check for test fixture '#{file.ext(@configurator.extension_executable)}' finds that #{message}\n" +
+             "  Possible causes:\n" +
+             "    1. Your test + source dereferenced a null pointer.\n" +
+             "    2. Your test + source indexed past the end of a buffer.\n" +
+             "    3. Your test + source committed a memory access violation.\n" +
+             "    4. Your test fixture produced an exit code of 0 despite execution ending prematurely.\n" +
+             "  Sanity check failures of test results are usually a symptom of interrupted test execution.\n\n"
+    
+    @streaminator.stderr_puts( notice )
+    raise
+  end
+
+end