ceedling 0.0.1

data/new_project_template/vendor/ceedling/vendor/cmock/lib/cmock_generator_utils.rb

@@ -0,0 +1,177 @@
+# ==========================================
+#   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
+
+  attr_accessor :config, :helpers, :ordered, :ptr_handling, :arrays, :cexception
+
+  def initialize(config, helpers={})
+    @config = config
+    @ptr_handling = @config.when_ptr
+    @ordered      = @config.enforce_strict_ordering
+    @arrays       = @config.plugins.include? :array
+    @cexception   = @config.plugins.include? :cexception
+    @treat_as     = @config.treat_as
+	  @helpers = helpers
+    
+    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 :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
+    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 << "  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
+  end
+  
+  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
+  end
+  
+  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| 
+          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" + 
+        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" + 
+        function[:args].inject("") { |all, arg| all + code_add_an_arg_expectation(arg) } +
+        "}\n\n"
+      end
+    else
+      ""
+    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" 
+    else
+      ""
+    end
+  end
+  
+  #private ######################
+  
+  def lookup_expect_type(function, arg)
+    c_type     = arg[:type]
+    arg_name   = arg[:name]
+    expected   = "cmock_call_instance->Expected_#{arg_name}" 
+    unity_func = if ((arg[:ptr?]) and ((c_type =~ /\*\*/) or (@ptr_handling == :compare_ptr)))
+                   ['UNITY_TEST_ASSERT_EQUAL_PTR', '']
+                 else
+                   (@helpers.nil? or @helpers[:unity_helper].nil?) ? ["UNITY_TEST_ASSERT_EQUAL",''] : @helpers[:unity_helper].get_helper(c_type)
+                 end
+    unity_msg  = "Function '#{function[:name]}' called with unexpected value for argument '#{arg_name}'."
+    return c_type, arg_name, expected, 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, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, \"#{unity_msg}\"); }\n"].join("\n")
+      when /_ARRAY/
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, \"#{unity_msg}\"); }\n"].join("\n")
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end  
+  end
+  
+  def code_verify_an_arg_expectation_with_normal_arrays(function, arg)
+    c_type, arg_name, expected, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+      when /_ARRAY/
+        if (pre == '&')
+          "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\");\n"
+        else
+          [ "  if (#{pre}#{expected} == NULL)",
+            "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+            "  else",
+            "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+        end
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end
+  end
+  
+  def code_verify_an_arg_expectation_with_smart_arrays(function, arg)
+    c_type, arg_name, expected, unity_func, pre, unity_msg = lookup_expect_type(function, arg)
+    depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1
+    case(unity_func)
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
+        c_type_local = c_type.gsub(/\*$/,'')
+        return "  UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, \"#{unity_msg}\");\n"
+      when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY"
+        [ "  if (#{pre}#{expected} == NULL)",
+          "    { UNITY_TEST_ASSERT_NULL(#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+          ((depth_name != 1) ? "  else if (#{depth_name} == 0)\n    { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\"); }" : nil),
+          "  else",
+          "    { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+      when /_ARRAY/
+        if (pre == '&')
+          "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\");\n"
+        else
+          [ "  if (#{pre}#{expected} == NULL)",
+            "    { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, \"Expected NULL. #{unity_msg}\"); }",
+            ((depth_name != 1) ? "  else if (#{depth_name} == 0)\n    { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\"); }" : nil),
+            "  else",
+            "    { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, \"#{unity_msg}\"); }\n"].compact.join("\n")
+        end
+      else
+        return "  #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, \"#{unity_msg}\");\n" 
+    end
+  end
+  
+end

data/new_project_template/vendor/ceedling/vendor/cmock/lib/cmock_header_parser.rb

@@ -0,0 +1,270 @@
+# ==========================================
+#   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
+    @c_attributes = (['const'] + cfg.attributes).uniq
+    @treat_as_void = (['void'] + cfg.treat_as_void).uniq
+    @declaration_parse_matcher = /([\d\w\s\*\(\),\[\]]+??)\(([\d\w\s\*\(\),\.\[\]+-]*)\)$/m
+    @standards = (['int','short','char','long','unsigned','signed'] + cfg.treat_as.keys).uniq
+    @when_no_prototypes = cfg.when_no_prototypes
+    @local_as_void = @treat_as_void
+    @verbosity = cfg.verbosity
+    @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
+    @typedefs = []
+    @funcs = []
+    function_names = []
+    
+    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)
+
+    # 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
+    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+([\w\d]+)\s*;/)
+    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!(/\/\/.*$/, '')                          # remove line comments (all that remain)
+
+    # remove assembler pragma sections
+    source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')
+    
+    # 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+)(?:#{@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
+    src_lines.delete_if {|line| !(line =~ /\(\s*\*(?:.*\[\d*\])??\s*\)/).nil?}     #remove function pointer arrays
+    if (@treat_externs == :include)
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:inline)\s+/).nil?}        #remove inline functions
+    else
+      src_lines.delete_if {|line| !(line =~ /(?:^|\s+)(?:extern|inline)\s+/).nil?} #remove inline and extern functions
+    end
+  end
+
+  def parse_functions(source)
+    funcs = []
+    source.each {|line| funcs << line.strip.gsub(/\s+/, ' ') if (line =~ @declaration_parse_matcher)}
+    if funcs.empty?
+      case @when_no_prototypes
+        when :error
+          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! 
+      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], 
+                :ptr?   => divine_ptr(arg_type),
+                :const? => arg_array.include?('const')
+              }
+    end
+    return args
+  end
+
+  def divine_ptr(arg_type)
+    return false unless arg_type.include? '*'
+    return false if arg_type.gsub(/(const|char|\*|\s)+/,'').empty?
+    return true
+  end
+
+  def clean_args(arg_list)
+    if ((@local_as_void.include?(arg_list.strip)) or (arg_list.empty?))
+      return 'void'
+    else
+      c=0
+      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*\*([\w\s\*]+)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
+        functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+        funcret  = $1.strip
+        funcname = $2.strip
+        funcargs = $3.strip
+        funconst = ''
+        if (funcname.include? 'const')
+          funcname.gsub!('const','').strip!
+          funconst = 'const '
+        end
+        @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});"
+        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| 
+        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}" 
+        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? 
+    
+    #grab argument list
+    args = regex_match[2].strip
+
+    #process function attributes, return type, and name
+    descriptors = regex_match[1]
+    descriptors.gsub!(/\s+\*/,'*')     #remove space to place asterisks with return type (where they belong)
+    descriptors.gsub!(/\*(\w)/,'* \1') #pull asterisks away from function name to place asterisks with return type (where they belong)
+    descriptors = descriptors.split    #array of all descriptor strings
+
+    #grab name
+    decl[:name] = descriptors[-1]      #snag name as last array item
+
+    #build attribute and return type strings
+    decl[:modifier] = []
+    rettype = []
+    descriptors[0..-2].each do |word|
+      if @c_attributes.include?(word)
+        decl[:modifier] << word
+      else
+        rettype << word
+      end
+    end
+    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', 
+                      :ptr?   => divine_ptr(rettype),
+                      :const? => rettype.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
+      if (args =~ /\,[\w\s]*\.\.\./)
+        args = args.gsub!(/\,[\w\s]*\.\.\./,'')
+      else
+        args = 'void'
+      end
+    else
+      decl[:var_arg] = nil
+    end
+    args = clean_args(args)
+    decl[:args_string] = args
+    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" +
+        "  declaration: '#{declaration}'\n" +
+        "  modifier: '#{decl[:modifier]}'\n" +
+        "  return: #{prototype_inspect_hash(decl[:return])}\n" +
+        "  function: '#{decl[:name]}'\n" +
+        "  args: #{prototype_inspect_array_of_hashes(decl[:args])}\n"
+    end
+
+    return decl
+  end
+
+  def prototype_inspect_hash(hash)
+    pairs = []
+    hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if (value.class == String)}#{value}#{"'" if (value.class == String)}" }
+    return "{#{pairs.join(', ')}}"
+  end
+
+  def prototype_inspect_array_of_hashes(array)
+    hashes = []
+    array.each { |hash| hashes << prototype_inspect_hash(hash) }
+    case (array.size)
+    when 0
+      return "[]"
+    when 1
+      return "[#{hashes[0]}]"
+    else
+      return "[\n    #{hashes.join("\n    ")}\n  ]\n"
+    end
+  end
+
+end

data/new_project_template/vendor/ceedling/vendor/cmock/lib/cmock_plugin_manager.rb

@@ -0,0 +1,40 @@
+# ==========================================
+#   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 CMockPluginManager
+
+  attr_accessor :plugins
+  
+  def initialize(config, utils)
+    @plugins = []
+    plugins_to_load = [:expect, config.plugins].flatten.uniq.compact
+    plugins_to_load.each do |plugin|
+      plugin_name = plugin.to_s
+      object_name = "CMockGeneratorPlugin" + camelize(plugin_name)
+      begin
+        unless (Object.const_defined? object_name)
+          require "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb"
+        end
+        @plugins << eval("#{object_name}.new(config, utils)")
+      rescue
+        raise "ERROR: CMock unable to load plugin '#{plugin_name}'"
+      end
+    end
+    @plugins.sort! {|a,b| a.priority <=> b.priority }
+  end
+  
+  def run(method, args=nil)
+    if args.nil?
+      return @plugins.collect{ |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join
+    else
+      return @plugins.collect{ |plugin| plugin.send(method, args) if plugin.respond_to?(method) }.flatten.join
+    end
+  end
+  
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/lib/cmock_unityhelper_parser.rb

@@ -0,0 +1,74 @@
+# ==========================================
+#   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 CMockUnityHelperParser
+  
+  attr_accessor :c_types
+  
+  def initialize(config)
+    @config = config
+    @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY'
+    @c_types = map_C_types.merge(import_source)
+  end
+
+  def get_helper(ctype)
+    lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/,'\1\3\5\6').strip.gsub(/\s+/,'_')
+    return [@c_types[lookup], ''] if (@c_types[lookup])
+    if (lookup =~ /\*$/)
+      lookup = lookup.gsub(/\*$/,'')
+      return [@c_types[lookup], '*'] if (@c_types[lookup])
+    else
+      lookup = lookup + '*'
+      return [@c_types[lookup], '&'] if (@c_types[lookup])
+    end
+    return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if (ctype =~ /cmock_\w+_ptr\d+/)
+    raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown
+    return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, '']
+  end
+  
+  private ###########################
+  
+  def map_C_types
+    c_types = {}
+    @config.treat_as.each_pair do |ctype, expecttype|
+      if (expecttype =~ /\*/)
+        c_types[ctype.gsub(/\s+/,'_')] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_ARRAY"
+      else
+        c_types[ctype.gsub(/\s+/,'_')] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}"
+        c_types[ctype.gsub(/\s+/,'_')+'*'] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY"
+      end
+    end
+    c_types
+  end
+  
+  def import_source
+    source = @config.load_unity_helper
+    return {} if source.nil?
+    c_types = {}
+    source = source.gsub(/\/\/.*$/, '') #remove line comments
+    source = source.gsub(/\/\*.*?\*\//m, '') #remove block comments
+     
+    #scan for comparison helpers
+    match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4,'\s*\w+\s*').join(',') + '\)')
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size/2).times do |i|
+      expect = pairs[i*2]
+      ctype = pairs[(i*2)+1]
+      c_types[ctype] = expect unless expect.include?("_ARRAY")
+    end
+      
+    #scan for array variants of those helpers
+    match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5,'\s*\w+\s*').join(',') + '\)')
+    pairs = source.scan(match_regex).flatten.compact
+    (pairs.size/2).times do |i|
+      expect = pairs[i*2]
+      ctype = pairs[(i*2)+1]
+      c_types[ctype.gsub('_ARRAY','*')] = expect
+    end
+    
+    c_types
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/rakefile.rb

@@ -0,0 +1,89 @@
+# ==========================================
+#   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 './config/test_environment'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require './rakefile_helper'
+
+include RakefileHelpers
+
+DEFAULT_CONFIG_FILE = 'gcc.yml'
+
+configure_clean
+configure_toolchain(DEFAULT_CONFIG_FILE)
+
+task :default => ['test:all']
+task :cruise => [:no_color, :default]
+
+desc "Load configuration"
+task :config, :config_file do |t, args|
+  args = {:config_file => DEFAULT_CONFIG_FILE} if args[:config_file].nil?
+  args = {:config_file => args[:config_file] + '.yml'} unless args[:config_file] =~ /\.yml$/i
+  configure_toolchain(args[:config_file])
+end
+
+namespace :test do
+  desc "Run all unit and system tests"
+  task :all => [:clobber, 'test:units', 'test:c', 'test:system']
+
+  desc "Run Unit Tests"
+  Rake::TestTask.new('units') do |t|
+    t.pattern = 'test/unit/*_test.rb'
+    t.verbose = true
+  end
+  
+  #individual unit tests
+  FileList['test/unit/*_test.rb'].each do |test|
+    Rake::TestTask.new(File.basename(test,'.*')) do |t|
+      t.pattern = test
+      t.verbose = true
+    end
+  end
+  
+  desc "Run C Unit Tests"
+  task :c do
+    build_and_test_c_files
+  end
+  
+  desc "Run System Tests"
+  task :system => [:clobber] do
+    #get a list of all system tests, removing unsupported tests for this compiler
+    sys_unsupported  = $cfg['unsupported'].map {|a| 'test/system/test_interactions/'+a+'.yml'}
+    sys_tests_to_run = FileList['test/system/test_interactions/*.yml'] - sys_unsupported
+    compile_unsupported  = $cfg['unsupported'].map {|a| SYSTEST_COMPILE_MOCKABLES_PATH+a+'.h'}
+    compile_tests_to_run = FileList[SYSTEST_COMPILE_MOCKABLES_PATH + '*.h'] - compile_unsupported
+    unless (sys_unsupported.empty? and compile_unsupported.empty?)
+      report "\nIgnoring these system tests..."
+      sys_unsupported.each {|a| report a}
+      compile_unsupported.each {|a| report a}
+    end
+    report "\nRunning system tests..."
+    tests_failed = run_system_test_interactions(sys_tests_to_run)
+    raise "System tests failed." if (tests_failed > 0)
+    
+    run_system_test_compilations(compile_tests_to_run)
+  end
+  
+  #individual system tests
+  FileList['test/system/test_interactions/*.yml'].each do |test|
+    desc "Run system test #{File.basename(test,'.*')}"
+    task "test:#{File.basename(test,'.*')}" do
+      run_system_test_interactions([test])
+    end
+  end
+  
+  desc "Profile Mock Generation"
+  task :profile => [:clobber] do
+    run_system_test_profiles(FileList[SYSTEST_COMPILE_MOCKABLES_PATH + '*.h'])
+  end
+end
+
+task :no_color do
+  $colour_output = false
+end
+