ceedling 0.29.0 → 0.29.1

data/lib/ceedling/test_invoker.rb

@@ -129,7 +129,7 @@ class TestInvoker
         @dependinator.enhance_test_build_object_dependencies( objects )
 
         # associate object files with executable
-        @dependinator.setup_test_executable_dependencies( test, objects )
+        @dependinator.enhance_test_executable_dependencies( test, objects )
 
         # build test objects
         @task_invoker.invoke_test_objects( objects )

data/lib/ceedling/version.rb

@@ -2,35 +2,49 @@
 # @private
 module Ceedling
   module Version
-    # Check for local or global version of vendor directory in order to look up versions
-    { 
-      "CEXCEPTION" => File.join("vendor","c_exception","lib","CException.h"),
-      "CMOCK"      => File.join("vendor","cmock","src","cmock.h"),
-      "UNITY"      => File.join("vendor","unity","src","unity.h"),
+    { "UNITY" => File.join("unity","src","unity.h"),
+      "CMOCK" => File.join("cmock","src","cmock.h"),
+      "CEXCEPTION" => File.join("c_exception","lib","CException.h") 
     }.each_pair do |name, path|
-      filename = if (File.exist?(File.join("..","..",path)))
-        File.join("..","..",path)
-      elsif (File.exist?(File.join(File.dirname(__FILE__),"..","..",path)))
-        File.join(File.dirname(__FILE__),"..","..",path)
+      # Check for local or global version of vendor directory in order to look up versions
+      path1 = File.expand_path( File.join("..","..","vendor",path) )
+      path2 = File.expand_path( File.join(File.dirname(__FILE__),"..","..","vendor",path) )
+      filename = if (File.exists?(path1))
+        path1
+      elsif (File.exists?(path2))
+        path2
+      elsif exists?(CEEDLING_VENDOR)
+        path3 = File.expand_path( File.join(CEEDLING_VENDOR,path) )
+        if (File.exists?(path3))
+          path3
+        else
+          basepath = File.join( CEEDLING_VENDOR, path.split(/\\\//)[0], 'release')
+          begin
+            [ @ceedling[:file_wrapper].read( File.join(base_path, 'release', 'version.info') ).strip, 
+              @ceedling[:file_wrapper].read( File.join(base_path, 'release', 'build.info') ).strip ].join('.')
+          rescue
+            "unknown"
+          end
+        end
       else
-        eval "#{name} = 'unknown'"
+        module_eval("#{name} = 'unknown'")
         continue
       end
 
       # Actually look up the versions
       a = [0,0,0]
-      File.readlines(filename) do |line|
+      File.readlines(filename).each do |line|
         ["VERSION_MAJOR", "VERSION_MINOR", "VERSION_BUILD"].each_with_index do |field, i|
           m = line.match(/#{name}_#{field}\s+(\d+)/)
           a[i] = m[1] unless (m.nil?)
         end
       end
 
-      # Make a constant from each, so that we can use it elsewhere
-      eval "#{name} = '#{a.join(".")}'"
+      # splat it to return the final value
+      eval("#{name} = '#{a.join(".")}'")
     end
 
-    GEM = "0.29.0"
+    GEM = "0.29.1"
     CEEDLING = GEM
   end
 end

data/plugins/gcov/gcov.rake

@@ -156,7 +156,7 @@ end
 namespace UTILS_SYM do
   def gcov_args_builder(opts)
     args = ""
-    args += "-r \"#{opts[:gcov_report_root] || '.'}\" " 
+    args += "-r \"#{opts[:gcov_report_root] || '.'}\" "
     args += "-f \"#{opts[:gcov_report_include]}\" " unless opts[:gcov_report_include].nil?
     args += "-e \"#{opts[:gcov_report_exclude] || GCOV_FILTER_EXCLUDE}\" "
     [ :gcov_fail_under_line, :gcov_fail_under_branch, :gcov_html_medium_threshold, :gcov_html_high_threshold].each do |opt|
@@ -165,7 +165,7 @@ namespace UTILS_SYM do
     return args
   end
 
-  desc 'Create gcov code coverage html report (must run ceedling gcov first)'
+  desc 'Create gcov code coverage html/xml report (must run ceedling gcov first).'
   task GCOV_SYM do
 
     if !File.directory? GCOV_ARTIFACTS_PATH
@@ -211,7 +211,7 @@ namespace UTILS_SYM do
 
     if xml_enabled
       puts "Creating an xml report of gcov results in #{GCOV_ARTIFACTS_FILE_XML}..."
-      command = @ceedling[:tool_executor].build_command_line(TOOLS_GCOV_POST_REPORT_XML, [], filter)
+      command = @ceedling[:tool_executor].build_command_line(TOOLS_GCOV_POST_REPORT_XML, [], args)
       @ceedling[:tool_executor].exec(command[:line], command[:options])
     end
 

data/plugins/junit_tests_report/lib/junit_tests_report.rb

@@ -109,11 +109,12 @@ class JunitTestsReport < Plugin
 
   def write_test( test, stream )
     test[:test].gsub!('"', '&quot;')
+    pp test
     case test[:result]
     when :success
-      stream.puts('    <testcase name="%<test>s" />' % test)
+      stream.puts('    <testcase name="%<test>s" time="%<unity_test_time>f"/>' % test)
     when :failed
-      stream.puts('    <testcase name="%<test>s">' % test)
+      stream.puts('    <testcase name="%<test>s" time="%<unity_test_time>f">' % test)
       if test[:message].empty?
         stream.puts('      <failure />')
       else
@@ -121,7 +122,7 @@ class JunitTestsReport < Plugin
       end
       stream.puts('    </testcase>')
     when :ignored
-      stream.puts('    <testcase name="%<test>s">' % test)
+      stream.puts('    <testcase name="%<test>s" time="%<unity_test_time>f">' % test)
       stream.puts('      <skipped />')
       stream.puts('    </testcase>')
     end

data/spec/spec_system_helper.rb

@@ -38,6 +38,24 @@ def _add_path_in_section(project_file_path, path, section)
   end
 end
 
+def _add_define_in_section(project_file_path, define, section)
+  project_file_contents = File.readlines(project_file_path)
+  defines_index = project_file_contents.index(":defines:\n")
+
+  if defines_index.nil?
+    # Something wrong with project.yml file, no defines?
+    return
+  end
+
+  section_index =  defines_index + project_file_contents[defines_index..-1].index("  :#{section}:\n")
+
+  project_file_contents.insert(section_index + 1, "    - #{define}\n")
+
+  File.open(project_file_path, "w+") do |f|
+    f.puts(project_file_contents)
+  end
+end
+
 def add_source_path(path)
   _add_path_in_section("project.yml", path, "source")
 end
@@ -46,6 +64,10 @@ def add_test_path(path)
   _add_path_in_section("project.yml", path, "test")
 end
 
+def add_test_define(define)
+  _add_define_in_section("project.yml", define, "test")
+end
+
 def add_module_generator_section(project_file_path, mod_gen)
   project_file_contents = File.readlines(project_file_path)
   module_gen_index = project_file_contents.index(":module_generator:\n")
@@ -198,7 +220,7 @@ module CeedlingTestCases
 
   def can_upgrade_projects
     @c.with_context do
-      output = `bundle exec ruby -S ceedling upgrade --local --docs #{@proj_name} 2>&1`
+      output = `bundle exec ruby -S ceedling upgrade #{@proj_name} 2>&1`
       expect($?.exitstatus).to match(0)
       expect(output).to match(/upgraded!/i)
       Dir.chdir @proj_name do
@@ -206,7 +228,6 @@ module CeedlingTestCases
         expect(File.exists?("src")).to eq true
         expect(File.exists?("test")).to eq true
         all_docs = Dir["vendor/ceedling/docs/*.pdf"].length + Dir["vendor/ceedling/docs/*.md"].length
-        expect(all_docs).to be >= 4
       end
     end
   end
@@ -296,6 +317,24 @@ module CeedlingTestCases
     end
   end
 
+  def can_test_projects_with_unity_exec_time
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
+        add_test_define("UNITY_INCLUDE_EXEC_TIME")
+
+        output = `bundle exec ruby -S ceedling 2>&1`
+        expect($?.exitstatus).to match(0) # Since a test either pass or are ignored, we return success here
+        expect(output).to match(/TESTED:\s+\d/)
+        expect(output).to match(/PASSED:\s+\d/)
+        expect(output).to match(/FAILED:\s+\d/)
+        expect(output).to match(/IGNORED:\s+\d/)
+      end
+    end
+  end
+
   def can_test_projects_with_fail
     @c.with_context do
       Dir.chdir @proj_name do
@@ -312,6 +351,7 @@ module CeedlingTestCases
       end
     end
   end
+
   def can_test_projects_with_fail_alias
     @c.with_context do
       Dir.chdir @proj_name do

data/spec/support/test_example.fail

@@ -7,9 +7,11 @@
 - :test: test_one
   :line: 257
   :message: ''
+  :unity_test_time: 0
 - :test: test_two
   :line: 269
   :message: ''
+  :unity_test_time: 0
 :ignores: []
 :counts:
   :total: 2

data/spec/support/test_example.pass

@@ -6,9 +6,11 @@
 - :test: test_one
   :line: 257
   :message: ''
+  :unity_test_time: 0
 - :test: test_two
   :line: 269
   :message: ''
+  :unity_test_time: 0
 :failures: []
 :ignores: []
 :counts:

data/spec/support/test_example_ignore.pass

@@ -8,9 +8,11 @@
 - :test: test_one
   :line: 257
   :message: ''
+  :unity_test_time: 0
 - :test: test_two
   :line: 269
   :message: ''
+  :unity_test_time: 0
 :counts:
   :total: 2
   :passed: 0

data/spec/support/test_example_mangled.pass

@@ -6,6 +6,7 @@
 - :test: test_one
   :line: 257
   :message: ''
+  :unity_test_time: 0
 - 
 :failures: []
 :ignores: []

data/spec/support/test_example_with_time.pass

@@ -6,9 +6,11 @@
 - :test: test_one
   :line: 257
   :message: ''
+  :unity_test_time: 0
 - :test: test_two
   :line: 269
   :message: ''
+  :unity_test_time: 0
 :failures: []
 :ignores: []
 :counts:

data/spec/system/deployment_spec.rb

@@ -30,6 +30,7 @@ describe "Ceedling" do
     it { can_test_projects_with_success }
     it { can_test_projects_with_success_test_alias }
     it { can_test_projects_with_success_default }
+    it { can_test_projects_with_unity_exec_time }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_fail_alias }
     it { can_test_projects_with_fail_default }
@@ -76,6 +77,7 @@ describe "Ceedling" do
     it { can_test_projects_with_success }
     it { can_test_projects_with_success_test_alias }
     it { can_test_projects_with_success_default }
+    it { can_test_projects_with_unity_exec_time }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_fail_alias }
     it { can_test_projects_with_fail_default }
@@ -103,6 +105,7 @@ describe "Ceedling" do
     it { can_test_projects_with_success }
     it { can_test_projects_with_success_test_alias }
     it { can_test_projects_with_success_default }
+    it { can_test_projects_with_unity_exec_time }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_fail_alias }
     it { can_test_projects_with_fail_default }
@@ -117,11 +120,13 @@ describe "Ceedling" do
 
     it { can_upgrade_projects }
     it { contains_a_vendor_directory }
+    it { does_not_contain_documentation }
     it { can_fetch_non_project_help }
     it { can_fetch_project_help }
     it { can_test_projects_with_success }
     it { can_test_projects_with_success_test_alias }
     it { can_test_projects_with_success_default }
+    it { can_test_projects_with_unity_exec_time }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_fail_alias }
     it { can_test_projects_with_fail_default }
@@ -149,6 +154,7 @@ describe "Ceedling" do
     it { can_test_projects_with_success }
     it { can_test_projects_with_success_test_alias }
     it { can_test_projects_with_success_default }
+    it { can_test_projects_with_unity_exec_time }
     it { can_test_projects_with_fail }
     it { can_test_projects_with_compile_error }
     it { can_use_the_module_plugin }

data/vendor/cmock/docs/CMock_Summary.md

@@ -518,6 +518,14 @@ from the defaults. We've tried to specify what the defaults are below.
   * `:include` will mock externed functions
   * `:exclude` will ignore externed functions (default).
 
+* `:treat_inlines`:
+  This specifies how you want CMock to handle functions that have been
+  marked as inline in the header file. Should it mock them?
+
+  * `:include` will mock inlined functions
+  * `:exclude` will ignore inlined functions (default).
+
+
 * `:unity_helper_path`:
   If you have created a header with your own extensions to unity to
   handle your own types, you can set this argument to that path. CMock
@@ -686,4 +694,3 @@ you might tool CMock into your build process. You may also want to consider
 using [Ceedling](https://throwtheswitch.org/ceedling). Please note that
 these examples are meant to show how the build process works. They have
 failing tests ON PURPOSE to show what that would look like. Don't be alarmed. ;)
-

data/vendor/cmock/lib/cmock_config.rb

@@ -29,6 +29,7 @@ class CMockConfig
     :when_ptr                    => :compare_data,   #the options being :compare_ptr, :compare_data, or :smart
     :verbosity                   => 2,               #the options being 0 errors only, 1 warnings and errors, 2 normal info, 3 verbose
     :treat_externs               => :exclude,        #the options being :include or :exclude
+    :treat_inlines               => :exclude,        #the options being :include or :exclude
     :callback_include_count      => true,
     :callback_after_arg_check    => false,
     :includes                    => nil,
@@ -64,7 +65,16 @@ class CMockConfig
     end
     options[:unity_helper_path] ||= options[:unity_helper]
     options[:unity_helper_path] = [options[:unity_helper_path]] if options[:unity_helper_path].is_a? String
-    options[:includes_c_post_header] = ((options[:includes_c_post_header] || []) + (options[:unity_helper_path] || [])).uniq
+
+    if options[:unity_helper_path]
+      require 'pathname'
+      includes1 = options[:includes_c_post_header] || []
+      includes2 = options[:unity_helper_path].map do |path|
+        Pathname(path).relative_path_from(Pathname(options[:mock_path])).to_s
+      end
+      options[:includes_c_post_header] = (includes1 + includes2).uniq
+    end
+
     options[:plugins].compact!
     options[:plugins].map! {|p| p.to_sym}
     @options = options

data/vendor/cmock/lib/cmock_generator.rb

@@ -16,6 +16,7 @@ class CMockGenerator
     @prefix      = @config.mock_prefix
     @suffix      = @config.mock_suffix
     @weak        = @config.weak
+    @include_inline        = @config.treat_inlines
     @ordered     = @config.enforce_strict_ordering
     @framework   = @config.framework.to_s
     @fail_on_unexpected_calls = @config.fail_on_unexpected_calls
@@ -61,6 +62,12 @@ class CMockGenerator
   end
 
   def create_mock_header_file(parsed_stuff)
+    if @include_inline == :include
+      @file_writer.create_file(@module_name + ".h", @subdir) do |file, filename|
+        file << parsed_stuff[:normalized_source]
+      end
+    end
+
     @file_writer.create_file(@mock_name + ".h", @subdir) do |file, filename|
       create_mock_header_header(file, filename)
       create_mock_header_service_call_declarations(file)

data/vendor/cmock/lib/cmock_generator_plugin_callback.rb

@@ -60,9 +60,9 @@ class CMockGeneratorPluginCallback
         "    UNITY_CLR_DETAILS();\n" \
         "    return;\n  }\n"
       else
-        "    #{function[:return][:type]} ret = #{generate_call(function)};\n" \
+        "    #{function[:return][:type]} cmock_cb_ret = #{generate_call(function)};\n" \
         "    UNITY_CLR_DETAILS();\n" \
-        "    return ret;\n  }\n"
+        "    return cmock_cb_ret;\n  }\n"
       end
   end
 

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -6,7 +6,7 @@
 
 class CMockHeaderParser
 
-  attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs
+  attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs, :treat_inlines
 
   def initialize(cfg)
     @funcs = []
@@ -24,13 +24,16 @@ class CMockHeaderParser
     @local_as_void = @treat_as_void
     @verbosity = cfg.verbosity
     @treat_externs = cfg.treat_externs
+    @treat_inlines = cfg.treat_inlines
     @c_strippables += ['extern'] if (@treat_externs == :include) #we'll need to remove the attribute if we're allowing externs
+    @c_strippables += ['inline'] if (@treat_inlines == :include) #we'll need to remove the attribute if we're allowing inlines
   end
 
   def parse(name, source)
     @module_name = name.gsub(/\W/,'')
     @typedefs = []
     @funcs = []
+    @normalized_source = nil
     function_names = []
 
     parse_functions( import_source(source) ).map do |decl|
@@ -41,14 +44,113 @@ class CMockHeaderParser
       end
     end
 
+    @normalized_source = if (@treat_inlines == :include)
+                           transform_inline_functions(source)
+                         else
+                           ''
+                         end
+
     { :includes  => nil,
       :functions => @funcs,
-      :typedefs  => @typedefs
+      :typedefs  => @typedefs,
+      :normalized_source    => @normalized_source
     }
   end
 
   private if $ThisIsOnlyATest.nil? ################
 
+  def remove_nested_pairs_of_braces(source)
+    # remove nested pairs of braces because no function declarations will be inside of them (leave outer pair for function definition detection)
+    if (RUBY_VERSION.split('.')[0].to_i > 1)
+      #we assign a string first because (no joke) if Ruby 1.9.3 sees this line as a regex, it will crash.
+      r = "\\{([^\\{\\}]*|\\g<0>)*\\}"
+      source.gsub!(/#{r}/m, '{ }')
+    else
+      while source.gsub!(/\{[^\{\}]*\{[^\{\}]*\}[^\{\}]*\}/m, '{ }')
+      end
+    end
+
+    return source
+  end
+
+  # Return the number of pairs of braces/square brackets in the function provided by the user
+  # +source+:: String containing the function to be processed
+  def count_number_of_pairs_of_braces_in_function(source)
+    is_function_start_found = false
+    curr_level = 0
+    total_pairs = 0
+
+    source.each_char do |c|
+      if ("{" == c)
+        curr_level += 1
+        total_pairs  +=1
+        is_function_start_found = true
+      elsif ("}" == c)
+        curr_level -=1
+      end
+
+      break if is_function_start_found && curr_level == 0    # We reached the end of the inline function body
+    end
+
+    if 0 != curr_level
+      total_pairs = 0          # Something is fishy about this source, not enough closing braces?
+    end
+
+    return total_pairs
+  end
+
+  # Transform inline functions to regular functions in the source by the user
+  # +source+:: String containing the source to be processed
+  def transform_inline_functions(source)
+    # Format to look for inline functions.
+    # This is a combination of "static" and "inline" keywords ("static inline", "inline static", "inline", "static")
+    # There are several possibilities:
+    # - sometimes they appear together, sometimes individually,
+    # - The keywords can appear before or after the return type (this is a compiler warning but people do weird stuff),
+    #   so we check for word boundaries when searching for them
+    # - We first remove "static inline" combinations and boil down to single inline or static statements
+    inline_function_regex_formats = [
+      /(static\s+inline|inline\s+static)\s*/,        # Last part (\s*) is just to remove whitespaces (only to prettify the output)
+      /(\bstatic\b|\binline\b)\s*/,                  # Last part (\s*) is just to remove whitespaces (only to prettify the output)
+    ]
+    square_bracket_pair_regex_format = /\{[^\{\}]*\}/ # Regex to match one whole block enclosed by two square brackets
+
+    # let's clean up the encoding in case they've done anything weird with the characters we might find
+    source = source.force_encoding("ISO-8859-1").encode("utf-8", :replace => nil)
+
+    # - Just looking for static|inline in the gsub is a bit too aggressive (functions that are named like this, ...), so we try to be a bit smarter
+    #   Instead, look for "static inline" and parse it:
+    #   - Everything before the match should just be copied, we don't want
+    #     to touch anything but the inline functions.
+    #   - Remove the implementation of the inline function (this is enclosed
+    #     in square brackets) and replace it with ";" to complete the
+    #     transformation to normal/non-inline function.
+    #     To ensure proper removal of the function body, we count the number of square-bracket pairs
+    #     and remove the pairs one-by-one.
+    #   - Copy everything after the inline function implementation and start the parsing of the next inline function
+
+    inline_function_regex_formats.each do |format|
+      loop do
+        inline_function_match = source.match(/#{format}/) # Search for inline function declaration
+        break if nil == inline_function_match             # No inline functions so nothing to do
+
+        total_pairs_to_remove = count_number_of_pairs_of_braces_in_function(inline_function_match.post_match)
+
+        break if 0 == total_pairs_to_remove # Bad source?
+
+        inline_function_stripped = inline_function_match.post_match
+
+        total_pairs_to_remove.times do
+          inline_function_stripped.sub!(/\s*#{square_bracket_pair_regex_format}/, ";") # Remove inline implementation (+ some whitespace because it's prettier)
+        end
+
+        source = inline_function_match.pre_match + inline_function_stripped # Make new source with the inline function removed and move on to the next
+      end
+    end
+
+    return source
+  end
+
   def import_source(source)
 
     # let's clean up the encoding in case they've done anything weird with the characters we might find
@@ -100,16 +202,15 @@ class CMockHeaderParser
       "#{functype} #{$2.strip}(#{$3});"
     end
 
-    # remove nested pairs of braces because no function declarations will be inside of them (leave outer pair for function definition detection)
-    if (RUBY_VERSION.split('.')[0].to_i > 1)
-      #we assign a string first because (no joke) if Ruby 1.9.3 sees this line as a regex, it will crash.
-      r = "\\{([^\\{\\}]*|\\g<0>)*\\}"
-      source.gsub!(/#{r}/m, '{ }')
-    else
-      while source.gsub!(/\{[^\{\}]*\{[^\{\}]*\}[^\{\}]*\}/m, '{ }')
-      end
+    source = remove_nested_pairs_of_braces(source)
+
+    if (@treat_inlines == :include)
+      # Functions having "{ }" at this point are/were inline functions,
+      # User wants them in so 'disguise' them as normal functions with the ";"
+      source.gsub!("{ }", ";")
     end
 
+
     # remove function definitions by stripping off the arguments right now
     source.gsub!(/\([^\)]*\)\s*\{[^\}]*\}/m, ";")
 
@@ -124,11 +225,20 @@ class CMockHeaderParser
     src_lines = source.split(/\s*;\s*/).uniq
     src_lines.delete_if {|line| line.strip.length == 0}                            # remove blank lines
     src_lines.delete_if {|line| !(line =~ /[\w\s\*]+\(+\s*\*[\*\s]*[\w\s]+(?:\[[\w\s]*\]\s*)+\)+\s*\((?:[\w\s\*]*,?)*\s*\)/).nil?}     #remove function pointer arrays
-    if (@treat_externs == :include)
-      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:inline)\s+/).nil?}        # remove inline functions
+
+    unless (@treat_externs == :include)
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern)\s+/).nil?} # remove extern functions
+    end
+
+    if (@treat_inlines == :include)
+      src_lines.each {
+        |src_line|
+        src_line.gsub!(/^inline/, "") # Remove "inline" so that they are 'normal' functions
+      }
     else
-      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern|inline)\s+/).nil?} # remove inline and extern functions
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:inline)\s+/).nil?}        # remove inline functions
     end
+
     src_lines.delete_if {|line| line.empty? } #drop empty lines
   end