ceedling 0.31.1 → 1.0.1

data/vendor/cmock/lib/cmock_generator_plugin_return_thru_ptr.rb

@@ -1,10 +1,23 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 class CMockGeneratorPluginReturnThruPtr
   attr_reader :priority
   attr_accessor :utils
 
-  def initialize(_config, utils)
+  def initialize(config, utils)
     @utils        = utils
     @priority     = 9
+    @config       = config
+  end
+
+  def ptr_to_const(arg_type)
+    # replace last "*" with " const*"
+    arg_type.gsub(/(.*)\*/, '\1 const*')
   end
 
   def instance_typedefs(function)
@@ -13,12 +26,21 @@ class CMockGeneratorPluginReturnThruPtr
       next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?])
 
       lines << "  char ReturnThruPtr_#{arg[:name]}_Used;\n"
-      lines << "  #{arg[:type]} ReturnThruPtr_#{arg[:name]}_Val;\n"
+      lines << "  #{ptr_to_const(arg[:type])} ReturnThruPtr_#{arg[:name]}_Val;\n"
       lines << "  size_t ReturnThruPtr_#{arg[:name]}_Size;\n"
     end
     lines
   end
 
+  def void_pointer?(type)
+    # returns true if the provided type is a void, or is supposed to be treated as void
+    if type.casecmp?('void')
+      true
+    else
+      @config.respond_to?(:treat_as_void) ? @config.treat_as_void.include?(type) : false
+    end
+  end
+
   def mock_function_declarations(function)
     lines = ''
     function[:args].each do |arg|
@@ -27,16 +49,17 @@ class CMockGeneratorPluginReturnThruPtr
       lines << "#define #{function[:name]}_ReturnThruPtr_#{arg[:name]}(#{arg[:name]})"
       # If the pointer type actually contains an asterisk, we can do sizeof the type (super safe), otherwise
       # we need to do a sizeof the dereferenced pointer (which could be a problem if give the wrong size
-      lines << if arg[:type][-1] == '*'
+      # however if its a void pointer we are given then we have to use the provided parameter name because sizeof(void) is UB.
+      lines << if (arg[:type][-1] == '*') && (void_pointer?(arg[:type][0..-2]) == false)
                  " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(#{arg[:type][0..-2]}))\n"
                else
                  " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(*#{arg[:name]}))\n"
                end
       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]}, (cmock_len * 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]}, size_t cmock_size);\n"
+      lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, (cmock_size))\n"
+      lines << "void #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(UNITY_LINE_TYPE cmock_line, #{ptr_to_const(arg[:type])} #{arg[:name]}, size_t cmock_size);\n"
     end
     lines
   end
@@ -48,7 +71,7 @@ class CMockGeneratorPluginReturnThruPtr
       arg_name = arg[:name]
       next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?])
 
-      lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg_name}, size_t cmock_size)\n"
+      lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{ptr_to_const(arg[:type])} #{arg_name}, size_t cmock_size)\n"
       lines << "{\n"
       lines << "  CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = " \
                "(CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.#{func_name}_CallInstance));\n"
@@ -70,7 +93,7 @@ class CMockGeneratorPluginReturnThruPtr
       lines << "  if (cmock_call_instance->ReturnThruPtr_#{arg_name}_Used)\n"
       lines << "  {\n"
       lines << "    UNITY_TEST_ASSERT_NOT_NULL(#{arg_name}, cmock_line, CMockStringPtrIsNULL);\n"
-      lines << "    memcpy((void*)#{arg_name}, (void*)cmock_call_instance->ReturnThruPtr_#{arg_name}_Val,\n"
+      lines << "    memcpy((void*)#{arg_name}, (const void*)cmock_call_instance->ReturnThruPtr_#{arg_name}_Val,\n"
       lines << "      cmock_call_instance->ReturnThruPtr_#{arg_name}_Size);\n"
       lines << "  }\n"
     end

data/vendor/cmock/lib/cmock_generator_utils.rb

@@ -1,8 +1,9 @@
-# ==========================================
-#   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]
-# ==========================================
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class CMockGeneratorUtils
   attr_accessor :config, :helpers, :ordered, :ptr_handling, :arrays, :cexception
@@ -63,7 +64,7 @@ class CMockGeneratorUtils
 
   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 && (depth.class == String)
+    lines << "  cmock_call_instance->Expected_#{arg[:name]}_Depth = #{arg[:name]}_Depth;\n" if @arrays && depth.instance_of?(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 && ptr_or_str?(arg[:type]) && !(arg[:const?])
     lines
@@ -88,13 +89,13 @@ class CMockGeneratorUtils
           m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
         end.join(', ')
         "void CMockExpectParameters_#{function[:name]}(CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance, #{args_string});\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)) } +
+          "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" \
-          "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) } +
+          "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

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -1,8 +1,9 @@
-# ==========================================
-#   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]
-# ==========================================
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class CMockHeaderParser
   attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs, :treat_inlines, :inline_function_patterns
@@ -14,7 +15,7 @@ class CMockHeaderParser
     @c_calling_conventions = cfg.c_calling_conventions.uniq
     @treat_as_array = cfg.treat_as_array
     @treat_as_void = (['void'] + cfg.treat_as_void).uniq
-    @function_declaration_parse_base_match = '([\w\s\*\(\),\[\]]+??)\(([\w\s\*\(\),\.\[\]+\-\/]*)\)'
+    @function_declaration_parse_base_match = '([\w\s\*\(\),\[\]]*?\w[\w\s\*\(\),\[\]]*?)\(([\w\s\*\(\),\.\[\]+\-\/]*)\)'
     @declaration_parse_matcher = /#{@function_declaration_parse_base_match}$/m
     @standards = (%w[int short char long unsigned signed] + cfg.treat_as.keys).uniq
     @array_size_name = cfg.array_size_name
@@ -39,7 +40,7 @@ class CMockHeaderParser
 
     function_names = []
 
-    all_funcs = parse_functions(import_source(source, parse_project)).map { |item| [item] }
+    all_funcs = parse_functions(name, import_source(source, parse_project)).map { |item| [item] }
     all_funcs += parse_cpp_functions(import_source(source, parse_project, true))
     all_funcs.map do |decl|
       func = parse_declaration(parse_project, *decl)
@@ -79,7 +80,7 @@ class CMockHeaderParser
       r = '\\{([^\\{\\}]*|\\g<0>)*\\}'
       source.gsub!(/#{r}/m, '{ }')
     else
-      while source.gsub!(/\{[^\{\}]*\{[^\{\}]*\}[^\{\}]*\}/m, '{ }')
+      while source.gsub!(/\{[^{}]*\{[^{}]*\}[^{}]*\}/m, '{ }')
       end
     end
 
@@ -94,11 +95,12 @@ class CMockHeaderParser
     total_pairs = 0
 
     source.each_char do |c|
-      if c == '{'
+      case c
+      when '{'
         curr_level += 1
         total_pairs += 1
         is_function_start_found = true
-      elsif c == '}'
+      when '}'
         curr_level -= 1
       end
 
@@ -116,14 +118,14 @@ class CMockHeaderParser
   # +source+:: String containing the source to be processed
   def transform_inline_functions(source)
     inline_function_regex_formats = []
-    square_bracket_pair_regex_format = /\{[^\{\}]*\}/ # Regex to match one whole block enclosed by two square brackets
+    square_bracket_pair_regex_format = /\{[^{}]*\}/ # Regex to match one whole block enclosed by two square brackets
 
     # Convert user provided string patterns to regex
     # Use word bounderies before and after the user regex to limit matching to actual word iso part of a word
     @inline_function_patterns.each do |user_format_string|
       user_regex = Regexp.new(user_format_string)
       word_boundary_before_user_regex = /\b/
-      cleanup_spaces_after_user_regex = /[ ]*\b/
+      cleanup_spaces_after_user_regex = / *\b/
       inline_function_regex_formats << Regexp.new(word_boundary_before_user_regex.source + user_regex.source + cleanup_spaces_after_user_regex.source)
     end
 
@@ -137,7 +139,7 @@ class CMockHeaderParser
     # If the user uses a macro to declare an inline function,
     # smushing the macros makes it easier to recognize them as a macro and if required,
     # remove them later on in this function
-    source.gsub!(/\s*\\\s*/m, ' ')
+    source.gsub!(/\s*\\(\n|\s*)/m, ' ')
 
     # 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 an inline pattern (f.e. "static inline") and parse it.
@@ -170,7 +172,7 @@ class CMockHeaderParser
         if /(#define\s*)\z/ =~ inline_function_match.pre_match
           # Remove the macro from the source
           stripped_pre_match = inline_function_match.pre_match.sub(/(#define\s*)\z/, '')
-          stripped_post_match = inline_function_match.post_match.sub(/\A(.*[\n]?)/, '')
+          stripped_post_match = inline_function_match.post_match.sub(/\A(.*\n?)/, '')
           inspected_source += stripped_pre_match
           source = stripped_post_match
           next
@@ -220,7 +222,7 @@ class CMockHeaderParser
     # 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]+)\s*;/)
+    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+(\w+)\s*;/)
     if void_types
       @local_as_void += void_types.flatten.uniq.compact
     end
@@ -245,18 +247,18 @@ class CMockHeaderParser
     source.gsub!(/__attribute(?:__)?\s*\(\(+.*\)\)+/, '')
 
     # remove preprocessor statements and extern "C"
+    source.gsub!(/extern\s+"C"\s*\{/, '')
     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|typedef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '')  # remove struct, union, and enum definitions and typedefs with braces
+    source.gsub!(/^[\w\s]*struct[^;{}()]+;/m, '') # remove forward declared structs
+    source.gsub!(/^[\w\s]*(enum|union|struct|typedef)[\w\s]*\{[^}]+\}[\w\s*,]*;/m, '') # remove struct, union, and enum definitions and typedefs with braces
     # remove problem keywords
     source.gsub!(/(\W)(?:register|auto|restrict)(\W)/, '\1\2')
     source.gsub!(/(\W)(?:static)(\W)/, '\1\2') unless cpp
 
-    source.gsub!(/\s*=\s*['"a-zA-Z0-9_\.]+\s*/, '')                                        # remove default value statements from argument lists
+    source.gsub!(/\s*=\s*['"a-zA-Z0-9_.]+\s*/, '') # remove default value statements from argument lists
     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
@@ -265,7 +267,7 @@ class CMockHeaderParser
     source.gsub!(/\w+\s*\(\s*\*\s*\w+\s*\)\s*\([^)]*\)\s*;/, ';')
 
     # 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|
+    source.gsub!(/([\w\s*]+)\(*\(\s*\*([\w\s*]+)\s*\(([\w\s*,]*)\)\)\s*\(([\w\s*,]*)\)\)*/) do |_m|
       functype = "cmock_#{parse_project[:module_name]}_func_ptr#{parse_project[:typedefs].size + 1}"
       unless cpp # only collect once
         parse_project[:typedefs] << "typedef #{Regexp.last_match(1).strip}(*#{functype})(#{Regexp.last_match(4)});"
@@ -282,7 +284,7 @@ class CMockHeaderParser
     end
 
     # remove function definitions by stripping off the arguments right now
-    source.gsub!(/\([^\)]*\)\s*\{[^\}]*\}/m, ';')
+    source.gsub!(/\([^)]*\)\s*\{[^}]*\}/m, ';')
 
     # drop extra white space to make the rest go faster
     source.gsub!(/^\s+/, '')          # remove extra white space from beginning of line
@@ -295,7 +297,7 @@ class CMockHeaderParser
     src_lines = source.split(/\s*;\s*/)
     src_lines = src_lines.uniq unless cpp # must retain closing braces for class/namespace
     src_lines.delete_if { |line| line.strip.empty? } # 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
+    src_lines.delete_if { |line| !(line =~ /[\w\s*]+\(+\s*\*[*\s]*[\w\s]+(?:\[[\w\s]*\]\s*)+\)+\s*\((?:[\w\s*]*,?)*\s*\)/).nil? } # remove function pointer arrays
 
     unless @treat_externs == :include
       src_lines.delete_if { |line| !(line =~ /(?:^|\s+)(?:extern)\s+/).nil? } # remove extern functions
@@ -357,15 +359,15 @@ class CMockHeaderParser
     funcs
   end
 
-  def parse_functions(source)
+  def parse_functions(filename, 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!'
+        raise "ERROR: No function prototypes found by CMock in #{filename}"
       when :warn
-        puts 'WARNING: No function prototypes found!' unless @verbosity < 1
+        puts "WARNING: No function prototypes found by CMock in #{filename}" unless @verbosity < 1
       end
     end
     funcs
@@ -484,23 +486,27 @@ class CMockHeaderParser
       arg_list.gsub!(/\*(\w)/, '* \1')
 
       # 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|
+      arg_list.gsub!(/([\w\s*]+)\(+([\w\s]*)\*[*\s]*([\w\s]*)\s*\)+\s*\(((?:[\w\s*]*,?)*)\s*\)*/) do |_m|
         functype = "cmock_#{parse_project[:module_name]}_func_ptr#{parse_project[:typedefs].size + 1}"
         funcret  = Regexp.last_match(1).strip
-        funcname = Regexp.last_match(2).strip
-        funcargs = Regexp.last_match(3).strip
+        funcdecl = Regexp.last_match(2).strip
+        funcname = Regexp.last_match(3).strip
+        funcargs = Regexp.last_match(4).strip
         funconst = ''
         if funcname.include? 'const'
           funcname.gsub!('const', '').strip!
           funconst = 'const '
         end
-        parse_project[:typedefs] << "typedef #{funcret}(*#{functype})(#{funcargs});"
+        if funcdecl != ''
+          funcdecl += ' '
+        end
+        parse_project[:typedefs] << "typedef #{funcret}(#{funcdecl}*#{functype})(#{funcargs});"
         funcname = "cmock_arg#{c += 1}" if funcname.empty?
         "#{functype} #{funconst}#{funcname}"
       end
 
       # scan argument list for function pointers with shorthand notation and replace them with custom types
-      arg_list.gsub!(/([\w\s\*]+)+\s+(\w+)\s*\(((?:[\w\s\*]*,?)*)\s*\)*/) do |_m|
+      arg_list.gsub!(/([\w\s*]+)\s+(\w+)\s*\(((?:[\w\s*]*,?)*)\s*\)*/) do |_m|
         functype = "cmock_#{parse_project[:module_name]}_func_ptr#{parse_project[:typedefs].size + 1}"
         funcret  = Regexp.last_match(1).strip
         funcname = Regexp.last_match(2).strip
@@ -570,13 +576,13 @@ class CMockHeaderParser
                       :const_ptr? => parsed[:const_ptr?] || false }
 
     # remove default argument statements from mock definitions
-    args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')
+    args.gsub!(/=\s*[a-zA-Z0-9_.]+\s*/, ' ')
 
     # check for var args
     if args =~ /\.\.\./
       decl[:var_arg] = args.match(/[\w\s]*\.\.\./).to_s.strip
-      args = if args =~ /\,[\w\s]*\.\.\./
-               args.gsub!(/\,[\w\s]*\.\.\./, '')
+      args = if args =~ /,[\w\s]*\.\.\./
+               args.gsub!(/,[\w\s]*\.\.\./, '')
              else
                'void'
              end
@@ -604,7 +610,7 @@ class CMockHeaderParser
 
   def prototype_inspect_hash(hash)
     pairs = []
-    hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if value.class == String}#{value}#{"'" if value.class == String}" }
+    hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if value.instance_of?(String)}#{value}#{"'" if value.instance_of?(String)}" }
     "{#{pairs.join(', ')}}"
   end
 
@@ -613,11 +619,11 @@ class CMockHeaderParser
     array.each { |hash| hashes << prototype_inspect_hash(hash) }
     case array.size
     when 0
-      return '[]'
+      '[]'
     when 1
-      return "[#{hashes[0]}]"
+      "[#{hashes[0]}]"
     else
-      return "[\n    #{hashes.join("\n    ")}\n  ]\n"
+      "[\n    #{hashes.join("\n    ")}\n  ]\n"
     end
   end
 end

data/vendor/cmock/lib/cmock_plugin_manager.rb

@@ -1,8 +1,9 @@
-# ==========================================
-#   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]
-# ==========================================
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class CMockPluginManager
   attr_accessor :plugins
@@ -12,7 +13,7 @@ class CMockPluginManager
     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)
+      object_name = "CMockGeneratorPlugin#{camelize(plugin_name)}"
       self.class.mutex.synchronize { load_plugin(plugin_name, object_name, config, utils) }
     end
     @plugins.sort! { |a, b| a.priority <=> b.priority }
@@ -27,7 +28,7 @@ class CMockPluginManager
   end
 
   def camelize(lower_case_and_underscored_word)
-    lower_case_and_underscored_word.gsub(/\/(.?)/) { '::' + Regexp.last_match(1).upcase }.gsub(/(^|_)(.)/) { Regexp.last_match(2).upcase }
+    lower_case_and_underscored_word.gsub(/\/(.?)/) { "::#{Regexp.last_match(1).upcase}" }.gsub(/(^|_)(.)/) { Regexp.last_match(2).upcase }
   end
 
   def self.mutex

data/vendor/cmock/lib/cmock_unityhelper_parser.rb

@@ -1,8 +1,9 @@
-# ==========================================
-#   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]
-# ==========================================
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class CMockUnityHelperParser
   attr_accessor :c_types
@@ -35,12 +36,16 @@ class CMockUnityHelperParser
   def map_c_types
     c_types = {}
     @config.treat_as.each_pair do |ctype, expecttype|
+      if ctype.is_a?(Symbol)
+        raise ":treat_as expects a list of  identifier: identifier  mappings, but got a symbol: #{ctype}. Check the indentation in your project.yml"
+      end
+
       c_type = ctype.gsub(/\s+/, '_')
       if expecttype =~ /\*/
         c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.delete('*')}_ARRAY"
       else
         c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype}"
-        c_types[c_type + '*'] ||= "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY"
+        c_types["#{c_type}*"] ||= "UNITY_TEST_ASSERT_EQUAL_#{expecttype}_ARRAY"
       end
     end
     c_types
@@ -55,7 +60,7 @@ class CMockUnityHelperParser
     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(',') + '\)')
+    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]
@@ -64,7 +69,7 @@ class CMockUnityHelperParser
     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(',') + '\)')
+    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]

data/vendor/cmock/lib/cmock_version.rb

@@ -0,0 +1,29 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+module CMockVersion
+  # Where is the header file from here?
+  path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'src', 'cmock.h'))
+
+  # Actually look up the version in the header file
+  a = [0, 0, 0]
+  begin
+    File.readlines(path).each do |line|
+      %w[VERSION_MAJOR VERSION_MINOR VERSION_BUILD].each_with_index do |field, i|
+        m = line.match(/CMOCK_#{field}\s+(\d+)/)
+        a[i] = m[1] unless m.nil?
+      end
+    end
+  rescue StandardError
+    abort('Can\'t find my header file.')
+  end
+
+  # splat it to return the final value
+  CMOCK_VERSION = a.join('.')
+
+  GEM = CMOCK_VERSION
+end

data/vendor/cmock/scripts/create_makefile.rb

@@ -1,3 +1,10 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'fileutils'
 ABS_ROOT = FileUtils.pwd
 CMOCK_DIR = File.expand_path(ENV.fetch('CMOCK_DIR', File.join(ABS_ROOT, '..', '..')))
@@ -20,7 +27,7 @@ TEST_BIN_DIR = TEST_BUILD_DIR
 MOCK_PREFIX = ENV.fetch('TEST_MOCK_PREFIX', 'mock_')
 MOCK_SUFFIX = ENV.fetch('TEST_MOCK_SUFFIX', '')
 TEST_MAKEFILE = ENV.fetch('TEST_MAKEFILE', File.join(TEST_BUILD_DIR, 'MakefileTestSupport'))
-MOCK_MATCHER = /#{MOCK_PREFIX}[A-Za-z_][A-Za-z0-9_\-\.]+#{MOCK_SUFFIX}/
+MOCK_MATCHER = /#{MOCK_PREFIX}[A-Za-z_][A-Za-z0-9_\-.]+#{MOCK_SUFFIX}/
 
 [TEST_BUILD_DIR, OBJ_DIR, RUNNERS_DIR, MOCKS_DIR, TEST_BIN_DIR].each do |dir|
   FileUtils.mkdir_p dir
@@ -83,7 +90,7 @@ File.open(TEST_MAKEFILE, 'w') do |mkfile|
     runner_source = File.join(RUNNERS_DIR, "runner_#{module_name}.c")
     runner_obj = File.join(OBJ_DIR, "runner_#{module_name}.o")
     test_bin = File.join(TEST_BIN_DIR, module_name)
-    test_results = File.join(TEST_BIN_DIR, module_name + '.testresult')
+    test_results = File.join(TEST_BIN_DIR, "#{module_name}.testresult")
 
     cfg = {
       src: test,
@@ -151,7 +158,7 @@ File.open(TEST_MAKEFILE, 'w') do |mkfile|
     all_headers_to_mock += headers_to_mock
     mock_objs = headers_to_mock.map do |hdr|
       mock_name = MOCK_PREFIX + File.basename(hdr, '.*')
-      File.join(MOCKS_DIR, mock_name + '.o')
+      File.join(MOCKS_DIR, "#{mock_name}.o")
     end
     all_headers_to_mock.uniq!
 
@@ -178,8 +185,8 @@ File.open(TEST_MAKEFILE, 'w') do |mkfile|
   all_headers_to_mock.each do |hdr|
     mock_name = MOCK_PREFIX + File.basename(hdr, '.*')
     mock_header = File.join(MOCKS_DIR, mock_name + File.extname(hdr))
-    mock_src = File.join(MOCKS_DIR, mock_name + '.c')
-    mock_obj = File.join(MOCKS_DIR, mock_name + '.o')
+    mock_src = File.join(MOCKS_DIR, "#{mock_name}.c")
+    mock_obj = File.join(MOCKS_DIR, "#{mock_name}.o")
 
     mkfile.puts "#{mock_src}: #{hdr}"
     mkfile.puts "\t@CMOCK_DIR=${CMOCK_DIR} ruby ${CMOCK_DIR}/scripts/create_mock.rb #{hdr}"
@@ -198,6 +205,6 @@ File.open(TEST_MAKEFILE, 'w') do |mkfile|
   mkfile.puts ''
 
   # Create target to run all tests
-  mkfile.puts "test: #{test_targets.map { |t| t + '.testresult' }.join(' ')} test_summary"
+  mkfile.puts "test: #{test_targets.map { |t| "#{t}.testresult" }.join(' ')} test_summary"
   mkfile.puts ''
 end

data/vendor/cmock/scripts/create_mock.rb

@@ -1,3 +1,10 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require "#{ENV['CMOCK_DIR']}/lib/cmock"
 
 raise 'Header file to mock must be specified!' unless ARGV.length >= 1

data/vendor/cmock/scripts/create_runner.rb

@@ -1,3 +1,10 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 if $0 == __FILE__
 
   # make sure there is at least one parameter left (the input file)

data/vendor/cmock/scripts/test_summary.rb

@@ -1,3 +1,10 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].casecmp('--SILENT') == 0)
 
 begin