ceedling 0.15.1 → 0.15.2

data/vendor/cmock/lib/cmock_generator_plugin_return_thru_ptr.rb

@@ -4,7 +4,7 @@ class CMockGeneratorPluginReturnThruPtr
 
   def initialize(config, utils)
     @utils        = utils
-    @priority     = 9
+    @priority     = 1
   end
 
   def instance_typedefs(function)
@@ -26,7 +26,7 @@ class CMockGeneratorPluginReturnThruPtr
         lines << "#define #{function[:name]}_ReturnThruPtr_#{arg[:name]}(#{arg[:name]})"
         lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(*#{arg[:name]}))\n"
         lines << "#define #{function[:name]}_ReturnArrayThruPtr_#{arg[:name]}(#{arg[:name]}, cmock_len)"
-        lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, cmock_len * sizeof(*#{arg[:name]}))\n"
+        lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, (int)(cmock_len * (int)sizeof(*#{arg[:name]})))\n"
         lines << "#define #{function[:name]}_ReturnMemThruPtr_#{arg[:name]}(#{arg[:name]}, cmock_size)"
         lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, cmock_size)\n"
         lines << "void #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg[:name]}, int cmock_size);\n"

data/vendor/cmock/lib/cmock_generator_utils.rb

@@ -2,7 +2,7 @@
 #   CMock Project - Automatic Mock Generation for C
 #   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
 #   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
+# ==========================================
 
 class CMockGeneratorUtils
 
@@ -14,61 +14,67 @@ class CMockGeneratorUtils
     @ordered      = @config.enforce_strict_ordering
     @arrays       = @config.plugins.include? :array
     @cexception   = @config.plugins.include? :cexception
+    @expect_any   = @config.plugins.include? :expect_any_args
     @return_thru_ptr = @config.plugins.include? :return_thru_ptr
     @ignore_arg   = @config.plugins.include? :ignore_arg
+    @ignore       = @config.plugins.include? :ignore
     @treat_as     = @config.treat_as
 	  @helpers = helpers
-    
+  end
+
+  def code_verify_an_arg_expectation(function, arg)
     if (@arrays)
       case(@ptr_handling)
-        when :smart        then alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_smart_arrays 
-        when :compare_data then alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_normal_arrays 
+        when :smart        then code_verify_an_arg_expectation_with_smart_arrays(function, arg)
+        when :compare_data then code_verify_an_arg_expectation_with_normal_arrays(function, arg)
         when :compare_ptr  then raise "ERROR: the array plugin doesn't enjoy working with :compare_ptr only.  Disable one option."
       end
     else
-      alias :code_verify_an_arg_expectation :code_verify_an_arg_expectation_with_no_arrays
+      code_verify_an_arg_expectation_with_no_arrays(function, arg)
     end
   end
-  
+
   def code_add_base_expectation(func_name, global_ordering_supported=true)
     lines =  "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_#{func_name}_CALL_INSTANCE));\n"
     lines << "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n"
     lines << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n"
     lines << "  Mock.#{func_name}_CallInstance = CMock_Guts_MemChain(Mock.#{func_name}_CallInstance, cmock_guts_index);\n"
+    lines << "  Mock.#{func_name}_IgnoreBool = (int)0;\n" if (@ignore)
     lines << "  cmock_call_instance->LineNumber = cmock_line;\n"
     lines << "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported)
     lines << "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception)
+    lines << "  cmock_call_instance->IgnoreMode = CMOCK_ARG_ALL;\n" if (@expect_any)
     lines
   end
-  
-  def code_add_an_arg_expectation(arg, depth=1) 
+
+  def code_add_an_arg_expectation(arg, depth=1)
     lines =  code_assign_argument_quickly("cmock_call_instance->Expected_#{arg[:name]}", arg)
     lines << "  cmock_call_instance->Expected_#{arg[:name]}_Depth = #{arg[:name]}_Depth;\n" if (@arrays and (depth.class == String))
     lines << "  cmock_call_instance->IgnoreArg_#{arg[:name]} = 0;\n" if (@ignore_arg)
     lines << "  cmock_call_instance->ReturnThruPtr_#{arg[:name]}_Used = 0;\n" if (@return_thru_ptr and ptr_or_str?(arg[:type]) and not arg[:const?])
     lines
   end
-  
-  def code_assign_argument_quickly(dest, arg) 
+
+  def code_assign_argument_quickly(dest, arg)
     if (arg[:ptr?] or @treat_as.include?(arg[:type]))
       "  #{dest} = #{arg[:const?] ? "(#{arg[:type]})" : ''}#{arg[:name]};\n"
     else
       "  memcpy(&#{dest}, &#{arg[:name]}, sizeof(#{arg[:type]}));\n"
     end
   end
-  
+
   def code_add_argument_loader(function)
     if (function[:args_string] != "void")
       if (@arrays)
-        args_string = function[:args].map do |m| 
+        args_string = function[:args].map do |m|
           const_str = m[ :const? ] ? 'const ' : ''
           m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
         end.join(', ')
-        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string})\n{\n" + 
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string})\n{\n" +
         function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg, (arg[:ptr?] ? "#{arg[:name]}_Depth" : 1) ) } +
         "}\n\n"
       else
-        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]})\n{\n" + 
+        "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{function[:args_string]})\n{\n" +
         function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg) } +
         "}\n\n"
       end
@@ -76,25 +82,25 @@ class CMockGeneratorUtils
       ""
     end
   end
-  
+
   def code_call_argument_loader(function)
     if (function[:args_string] != "void")
       args = function[:args].map do |m|
         (@arrays and m[:ptr?]) ? "#{m[:name]}, 1" : m[:name]
       end
-      "  CMockExpectParameters_#{function[:name]}(cmock_call_instance, #{args.join(', ')});\n" 
+      "  CMockExpectParameters_#{function[:name]}(cmock_call_instance, #{args.join(', ')});\n"
     else
       ""
     end
   end
-  
+
   def ptr_or_str?(arg_type)
     return (arg_type.include? '*' or
             @treat_as.fetch(arg_type, "").include? '*')
   end
 
   #private ######################
-  
+
   def lookup_expect_type(function, arg)
     c_type     = arg[:type]
     arg_name   = arg[:name]
@@ -108,7 +114,7 @@ class CMockGeneratorUtils
     unity_msg  = "Function '#{function[:name]}' called with unexpected value for argument '#{arg_name}'."
     return c_type, arg_name, expected, ignore, unity_func[0], unity_func[1], unity_msg
   end
-  
+
   def code_verify_an_arg_expectation_with_no_arrays(function, arg)
     c_type, arg_name, expected, ignore, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
     lines = ""
@@ -124,17 +130,21 @@ class CMockGeneratorUtils
         lines << "    else\n"
         lines << "      { UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, \"#{unity_msg}\"); }\n"
       when /_ARRAY/
-        lines << "    if (#{pre}#{expected} == NULL)\n"
-        lines << "      { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }\n"
-        lines << "    else\n"
-        lines << "      { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, \"#{unity_msg}\"); }\n"
+        if (pre == '&')
+          lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, \"#{unity_msg}\");\n"
+        else
+          lines << "    if (#{pre}#{expected} == NULL)\n"
+          lines << "      { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }\n"
+          lines << "    else\n"
+          lines << "      { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, \"#{unity_msg}\"); }\n"
+        end
       else
-        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n"
     end
     lines << "  }\n"
     lines
   end
-  
+
   def code_verify_an_arg_expectation_with_normal_arrays(function, arg)
     c_type, arg_name, expected, ignore, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
     depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
@@ -160,12 +170,12 @@ class CMockGeneratorUtils
           lines << "      { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"
         end
       else
-        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n"
     end
     lines << "  }\n"
     lines
   end
-  
+
   def code_verify_an_arg_expectation_with_smart_arrays(function, arg)
     c_type, arg_name, expected, ignore, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
     depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
@@ -193,10 +203,10 @@ class CMockGeneratorUtils
           lines << "      { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"
         end
       else
-        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+        lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n"
     end
     lines << "  }\n"
     lines
   end
-  
+
 end

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -2,12 +2,12 @@
 #   CMock Project - Automatic Mock Generation for C
 #   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
 #   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
+# ==========================================
 
 class CMockHeaderParser
 
   attr_accessor :funcs, :c_attributes, :treat_as_void, :treat_externs
-  
+
   def initialize(cfg)
     @funcs = []
     @c_strippables = cfg.strippables
@@ -22,31 +22,34 @@ class CMockHeaderParser
     @treat_externs = cfg.treat_externs
     @c_strippables += ['extern'] if (@treat_externs == :include) #we'll need to remove the attribute if we're allowing externs
   end
-  
+
   def parse(name, source)
     @module_name = name.gsub(/\W/,'')
     @typedefs = []
     @funcs = []
     function_names = []
-    
-    parse_functions( import_source(source) ).map do |decl| 
+
+    parse_functions( import_source(source) ).map do |decl|
       func = parse_declaration(decl)
       unless (function_names.include? func[:name])
         @funcs << func
         function_names << func[:name]
       end
     end
-    
+
     { :includes  => nil,
       :functions => @funcs,
       :typedefs  => @typedefs
     }
   end
-  
+
   private if $ThisIsOnlyATest.nil? ################
-  
+
   def import_source(source)
 
+    # 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) if ($QUICK_RUBY_VERSION > 10900)
+
     # void must be void for cmock _ExpectAndReturn calls to process properly, not some weird typedef which equates to void
     # to a certain extent, this action assumes we're chewing on pre-processed header files, otherwise we'll most likely just get stuff from @treat_as_void
     @local_as_void = @treat_as_void
@@ -54,48 +57,49 @@ class CMockHeaderParser
     if void_types
       @local_as_void += void_types.flatten.uniq.compact
     end
-  
+
     # smush multiline macros into single line (checking for continuation character at end of line '\')
     source.gsub!(/\s*\\\s*/m, ' ')
-   
+
     #remove comments (block and line, in three steps to ensure correct precedence)
     source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments 
+    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments
     source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
 
     # remove assembler pragma sections
     source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')
-    
+
     # remove gcc's __attribute__ tags
-    source.gsub(/__attrbute__\s*\(\(\.*\)\)/, '')
-    
-    # remove preprocessor statements and extern "C" 
+    source.gsub!(/__attribute(?:__)?\s*\(\(+.*\)\)+/, '')
+
+    # remove preprocessor statements and extern "C"
     source.gsub!(/^\s*#.*/, '')
     source.gsub!(/extern\s+\"C\"\s+\{/, '')
-    
+
     # enums, unions, structs, and typedefs can all contain things (e.g. function pointers) that parse like function prototypes, so yank them
     # forward declared structs are removed before struct definitions so they don't mess up real thing later. we leave structs keywords in function prototypes
     source.gsub!(/^[\w\s]*struct[^;\{\}\(\)]+;/m, '')                                      # remove forward declared structs
     source.gsub!(/^[\w\s]*(enum|union|struct|typepdef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '') # remove struct, union, and enum definitions and typedefs with braces
     source.gsub!(/(\W)(?:register|auto|static|restrict)(\W)/, '\1\2')                      # remove problem keywords
     source.gsub!(/\s*=\s*['"a-zA-Z0-9_\.]+\s*/, '')                                        # remove default value statements from argument lists
-    source.gsub!(/^(?:[\w\s]*\W)?typedef\W.*/, '')                                         # remove typedef statements
+    source.gsub!(/^(?:[\w\s]*\W)?typedef\W[^;]*/m, '')                                     # remove typedef statements
+    source.gsub!(/\)(\w)/, ') \1')                                                         # add space between parenthese and alphanumeric
     source.gsub!(/(^|\W+)(?:#{@c_strippables.join('|')})(?=$|\W+)/,'\1') unless @c_strippables.empty? # remove known attributes slated to be stripped
-    
+
     #scan for functions which return function pointers, because they are a pain
     source.gsub!(/([\w\s\*]+)\(*\(\s*\*([\w\s\*]+)\s*\(([\w\s\*,]*)\)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
       functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
       @typedefs << "typedef #{$1.strip}(*#{functype})(#{$4});"
       "#{functype} #{$2.strip}(#{$3});"
     end
-    
+
     #drop extra white space to make the rest go faster
     source.gsub!(/^\s+/, '')          # remove extra white space from beginning of line
     source.gsub!(/\s+$/, '')          # remove extra white space from end of line
     source.gsub!(/\s*\(\s*/, '(')     # remove extra white space from before left parens
     source.gsub!(/\s*\)\s*/, ')')     # remove extra white space from before right parens
     source.gsub!(/\s+/, ' ')          # remove remaining extra white space
-    
+
     #split lines on semicolons and remove things that are obviously not what we are looking for
     src_lines = source.split(/\s*;\s*/)
     src_lines.delete_if {|line| line.strip.length == 0}                            # remove blank lines
@@ -105,6 +109,9 @@ class CMockHeaderParser
     else
       src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern|inline)\s+/).nil?} # remove inline and extern functions
     end
+    src_lines.delete_if {|line| !(line =~ /\{/).nil? }  # remove lines with opening braces { because this isn't a declaration, it's a definition!
+    src_lines.map!{|line| line.gsub(/.*\}/,'')} #remove braces left at the beginning of lines
+    src_lines.delete_if {|line| line.empty? } #drop empty lines
   end
 
   def parse_functions(source)
@@ -113,23 +120,23 @@ class CMockHeaderParser
     if funcs.empty?
       case @when_no_prototypes
         when :error
-          raise "ERROR: No function prototypes found!" 
+          raise "ERROR: No function prototypes found!"
         when :warn
           puts "WARNING: No function prototypes found!" unless (@verbosity < 1)
       end
     end
     return funcs
   end
-  
+
   def parse_args(arg_list)
     args = []
     arg_list.split(',').each do |arg|
-      arg.strip! 
+      arg.strip!
       return args if (arg =~ /^\s*((\.\.\.)|(void))\s*$/)   # we're done if we reach void by itself or ...
       arg_array = arg.split
       arg_elements = arg_array - @c_attributes              # split up words and remove known attributes
-      args << { :type   => (arg_type =arg_elements[0..-2].join(' ')), 
-                :name   => arg_elements[-1], 
+      args << { :type   => (arg_type =arg_elements[0..-2].join(' ')),
+                :name   => arg_elements[-1],
                 :ptr?   => divine_ptr(arg_type),
                 :const? => arg_array.include?('const')
               }
@@ -151,7 +158,7 @@ class CMockHeaderParser
       arg_list.gsub!(/(\w+)(?:\s*\[[\s\d\w+-]*\])+/,'*\1')  # magically turn brackets into asterisks
       arg_list.gsub!(/\s+\*/,'*')                           # remove space to place asterisks with type (where they belong)
       arg_list.gsub!(/\*(\w)/,'* \1')                       # pull asterisks away from arg to place asterisks with type (where they belong)
-      
+
       #scan argument list for function pointers and replace them with custom types
       arg_list.gsub!(/([\w\s\*]+)\(+\s*\*[\*\s]*([\w\s]*)\s*\)+\s*\(((?:[\w\s\*]*,?)*)\s*\)*/) do |m|
 
@@ -168,25 +175,25 @@ class CMockHeaderParser
         funcname = "cmock_arg#{c+=1}" if (funcname.empty?)
         "#{functype} #{funconst}#{funcname}"
       end
-      
+
       #automatically name unnamed arguments (those that only had a type)
-      arg_list.split(/\s*,\s*/).map { |arg| 
+      arg_list.split(/\s*,\s*/).map { |arg|
         parts = (arg.split - ['struct', 'union', 'enum', 'const', 'const*'])
         if ((parts.size < 2) or (parts[-1][-1].chr == '*') or (@standards.include?(parts[-1])))
-          "#{arg} cmock_arg#{c+=1}" 
+          "#{arg} cmock_arg#{c+=1}"
         else
           arg
         end
       }.join(', ')
     end
   end
-  
+
   def parse_declaration(declaration)
     decl = {}
-    
+
     regex_match = @declaration_parse_matcher.match(declaration)
-    raise "Failed parsing function declaration: '#{declaration}'" if regex_match.nil? 
-    
+    raise "Failed parsing function declaration: '#{declaration}'" if regex_match.nil?
+
     #grab argument list
     args = regex_match[2].strip
 
@@ -214,17 +221,17 @@ class CMockHeaderParser
     decl[:modifier] = decl[:modifier].join(' ')
     rettype = rettype.join(' ')
     rettype = 'void' if (@local_as_void.include?(rettype.strip))
-    decl[:return] = { :type   => rettype, 
-                      :name   => 'cmock_to_return', 
+    decl[:return] = { :type   => rettype,
+                      :name   => 'cmock_to_return',
                       :ptr?   => divine_ptr(rettype),
-                      :const? => rettype.split(/\s/).include?('const'),
+                      :const? => decl[:modifier].split(/\s/).include?('const'),
                       :str    => "#{rettype} cmock_to_return",
                       :void?  => (rettype == 'void')
                     }
-        
+
     #remove default argument statements from mock definitions
     args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')
-    
+
     #check for var args
     if (args =~ /\.\.\./)
       decl[:var_arg] = args.match( /[\w\s]*\.\.\./ ).to_s.strip
@@ -241,7 +248,7 @@ class CMockHeaderParser
     decl[:args] = parse_args(args)
     decl[:args_call] = decl[:args].map{|a| a[:name]}.join(', ')
     decl[:contains_ptr?] = decl[:args].inject(false) {|ptr, arg| arg[:ptr?] ? true : ptr }
-      
+
     if (decl[:return][:type].nil?   or decl[:name].nil?   or decl[:args].nil? or
         decl[:return][:type].empty? or decl[:name].empty?)
       raise "Failed Parsing Declaration Prototype!\n" +

data/vendor/cmock/rakefile_helper.rb

@@ -2,7 +2,7 @@
 #   CMock Project - Automatic Mock Generation for C
 #   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
 #   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
+# ==========================================
 
 require 'yaml'
 require 'fileutils'
@@ -18,23 +18,23 @@ module RakefileHelpers
   SYSTEST_COMPILE_MOCKABLES_PATH = 'test/system/test_compilation/'
   C_EXTENSION = '.c'
   RESULT_EXTENSION = '.result'
-  
+
   def load_configuration(config_file)
     $cfg_file = config_file
     $cfg = YAML.load(File.read('./targets/' + $cfg_file))
     $colour_output = false unless $cfg['colour']
   end
-  
+
   def configure_clean
     CLEAN.include(SYSTEST_GENERATED_FILES_PATH + '*.*')
     CLEAN.include(SYSTEST_BUILD_FILES_PATH + '*.*')
   end
-  
+
   def configure_toolchain(config_file)
     load_configuration(config_file)
     configure_clean
   end
-  
+
   def get_local_include_dirs
     include_dirs = $cfg['compiler']['includes']['items'].dup
     include_dirs.delete_if {|dir| dir.is_a?(Array)}
@@ -90,7 +90,7 @@ module RakefileHelpers
     execute(cmd_str + obj_file)
     return obj_file
   end
-  
+
   def build_linker_fields
     command  = tackit($cfg['linker']['path'])
     if $cfg['linker']['options'].nil?
@@ -106,7 +106,7 @@ module RakefileHelpers
     includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
     return {:command => command, :options => options, :includes => includes}
   end
-  
+
   def link_it(exe_name, obj_list)
     linker = build_linker_fields
     cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
@@ -116,7 +116,7 @@ module RakefileHelpers
       exe_name + $cfg['linker']['bin_files']['extension']
     execute(cmd_str)
   end
-  
+
   def build_simulator_fields
     return nil if $cfg['simulator'].nil?
     if $cfg['simulator']['path'].nil?
@@ -136,7 +136,7 @@ module RakefileHelpers
     end
     return {:command => command, :pre_support => pre_support, :post_support => post_support}
   end
-  
+
   def execute(command_string, verbose=true, raise_on_failure=true)
     #report command_string
     output = `#{command_string}`.chomp
@@ -146,7 +146,7 @@ module RakefileHelpers
     end
     return output
   end
-  
+
   def tackit(strings)
     case(strings)
       when Array
@@ -159,7 +159,7 @@ module RakefileHelpers
         strings
     end
   end
-  
+
   def report_summary
     summary = UnityTestSummary.new
     summary.set_root_path(File.expand_path(File.dirname(__FILE__)) + '/')
@@ -170,28 +170,28 @@ module RakefileHelpers
     summary.run
     fail_out "FAIL: There were failures" if (summary.failures > 0)
   end
-  
+
   def run_system_test_interactions(test_case_files)
     load './lib/cmock.rb'
-    
+
     SystemTestGenerator.new.generate_files(test_case_files)
     test_files = FileList.new(SYSTEST_GENERATED_FILES_PATH + 'test*.c')
-    
+
     load_configuration($cfg_file)
     $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
-    
+
     include_dirs = get_local_include_dirs
 
     # Build and execute each unit test
     test_files.each do |test|
 
       obj_list = []
-      
+
       test_base    = File.basename(test, C_EXTENSION)
       cmock_config = test_base.gsub(/test_/, '') + '_cmock.yml'
-      
+
       report "Executing system tests in #{File.basename(test)}..."
-      
+
       # Detect dependencies and build required required modules
       extract_headers(test).each do |header|
 
@@ -213,13 +213,13 @@ module RakefileHelpers
       runner_path = $cfg['compiler']['source_path'] + runner_name
       UnityTestRunnerGenerator.new(SYSTEST_GENERATED_FILES_PATH + cmock_config).run(test, runner_path)
       obj_list << compile(runner_path)
-      
+
       # Build the test module
       obj_list << compile(test)
-      
+
       # Link the test executable
       link_it(test_base, obj_list)
-      
+
       # Execute unit test and generate results file
       simulator = build_simulator_fields
       executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
@@ -232,19 +232,19 @@ module RakefileHelpers
       test_results = $cfg['compiler']['build_path'] + test_base + RESULT_EXTENSION
       File.open(test_results, 'w') { |f| f.print output }
     end
-    
+
     # Parse and report test results
     total_tests = 0
     total_failures = 0
     failure_messages = []
 
-    test_case_files.each do |test_case|      
+    test_case_files.each do |test_case|
       tests = (YAML.load_file(test_case))[:systest][:tests][:units]
       total_tests += tests.size
 
       test_file    = 'test_' + File.basename(test_case).ext(C_EXTENSION)
       result_file  = test_file.ext(RESULT_EXTENSION)
-      test_results = File.readlines(SYSTEST_BUILD_FILES_PATH + result_file)
+      test_results = File.readlines(SYSTEST_BUILD_FILES_PATH + result_file).reject {|line| line.size < 10 } # we're rejecting lines that are too short to be realistic, which handles line ending problems
       tests.each_with_index do |test, index|
         # compare test's intended pass/fail state with pass/fail state in actual results;
         # if they don't match, the system test has failed
@@ -268,26 +268,26 @@ module RakefileHelpers
         end
       end
     end
-    
+
     report "\n"
     report "------------------------------------\n"
     report "SYSTEM TEST MOCK INTERACTION SUMMARY\n"
     report "------------------------------------\n"
     report "#{total_tests} Tests #{total_failures} Failures 0 Ignored\n"
     report "\n"
-    
+
     if (failure_messages.size > 0)
       report 'System test failures:'
       failure_messages.each do |failure|
         report failure
       end
     end
-    
+
     report ''
 
     return total_failures
   end
-  
+
   def profile_this(filename)
     profile = true
     begin
@@ -296,9 +296,9 @@ module RakefileHelpers
     rescue
       profile = false
     end
-    
+
     yield
-    
+
     if (profile)
       profile_result = RubyProf.stop
       File.open("Profile_#{filename}.html", 'w') do |f|
@@ -306,10 +306,10 @@ module RakefileHelpers
       end
     end
   end
-  
+
   def run_system_test_compilations(mockables)
     load './lib/cmock.rb'
-    
+
     load_configuration($cfg_file)
     $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
 
@@ -324,10 +324,10 @@ module RakefileHelpers
       compile(SYSTEST_GENERATED_FILES_PATH + mock_filename)
     end
   end
-  
+
   def run_system_test_profiles(mockables)
     load './lib/cmock.rb'
-    
+
     load_configuration($cfg_file)
     $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
 
@@ -337,8 +337,8 @@ module RakefileHelpers
     report "--------------------------\n"
     mockables.each do |header|
       mock_filename = 'mock_' + File.basename(header).ext('.c')
-      profile_this(mock_filename.gsub('.c','')) do 
-        10.times do 
+      profile_this(mock_filename.gsub('.c','')) do
+        10.times do
           CMock.new(SYSTEST_COMPILE_MOCKABLES_PATH + 'config.yml').setup_mocks(header)
         end
       end
@@ -346,7 +346,7 @@ module RakefileHelpers
       compile(SYSTEST_GENERATED_FILES_PATH + mock_filename)
     end
   end
-  
+
   def build_and_test_c_files
     report "\n"
     report "----------------\n"
@@ -372,7 +372,7 @@ module RakefileHelpers
       end
     end
   end
-  
+
   def fail_out(msg)
     puts msg
     exit(-1)