ceedling 0.31.0 → 1.0.0

data/vendor/cmock/lib/cmock_header_parser.rb

@@ -1,21 +1,21 @@
-# ==========================================
-#   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
 
   def initialize(cfg)
-    @funcs = []
     @c_strippables = cfg.strippables
     @c_attr_noconst = cfg.attributes.uniq - ['const']
     @c_attributes = ['const'] + c_attr_noconst
     @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
@@ -31,32 +31,35 @@ class CMockHeaderParser
   end
 
   def parse(name, source)
-    @module_name = name.gsub(/\W/, '')
-    @typedefs = []
-    @funcs = []
-    @normalized_source = nil
+    parse_project = {
+      :module_name       => name.gsub(/\W/, ''),
+      :typedefs          => [],
+      :functions         => [],
+      :normalized_source => nil
+    }
+
     function_names = []
 
-    all_funcs = parse_functions(import_source(source)).map { |item| [item] }
-    all_funcs += parse_cpp_functions(import_source(source, true))
+    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(*decl)
+      func = parse_declaration(parse_project, *decl)
       unless function_names.include? func[:name]
-        @funcs << func
+        parse_project[:functions] << func
         function_names << func[:name]
       end
     end
 
-    @normalized_source = if @treat_inlines == :include
-                           transform_inline_functions(source)
-                         else
-                           ''
-                         end
+    parse_project[:normalized_source] = if @treat_inlines == :include
+                                          transform_inline_functions(source)
+                                        else
+                                          ''
+                                        end
 
     { :includes  => nil,
-      :functions => @funcs,
-      :typedefs  => @typedefs,
-      :normalized_source    => @normalized_source }
+      :functions => parse_project[:functions],
+      :typedefs  => parse_project[:typedefs],
+      :normalized_source    => parse_project[:normalized_source] }
   end
 
   private if $ThisIsOnlyATest.nil? ################
@@ -77,7 +80,7 @@ class CMockHeaderParser
       r = '\\{([^\\{\\}]*|\\g<0>)*\\}'
       source.gsub!(/#{r}/m, '{ }')
     else
-      while source.gsub!(/\{[^\{\}]*\{[^\{\}]*\}[^\{\}]*\}/m, '{ }')
+      while source.gsub!(/\{[^{}]*\{[^{}]*\}[^{}]*\}/m, '{ }')
       end
     end
 
@@ -92,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
 
@@ -114,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
 
@@ -135,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.
@@ -168,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
@@ -211,14 +215,14 @@ class CMockHeaderParser
     source
   end
 
-  def import_source(source, cpp = false)
+  def import_source(source, parse_project, cpp = false)
     # 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)
 
     # 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
@@ -243,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
@@ -263,10 +267,10 @@ 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|
-      functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+    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
-        @typedefs << "typedef #{Regexp.last_match(1).strip}(*#{functype})(#{Regexp.last_match(4)});"
+        parse_project[:typedefs] << "typedef #{Regexp.last_match(1).strip}(*#{functype})(#{Regexp.last_match(4)});"
         "#{functype} #{Regexp.last_match(2).strip}(#{Regexp.last_match(3)});"
       end
     end
@@ -280,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
@@ -293,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
@@ -355,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
@@ -469,7 +473,7 @@ class CMockHeaderParser
     divination
   end
 
-  def clean_args(arg_list)
+  def clean_args(arg_list, parse_project)
     if @local_as_void.include?(arg_list.strip) || arg_list.empty?
       'void'
     else
@@ -482,24 +486,28 @@ 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|
-        functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+      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
-        @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|
-        functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
+      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
         funcargs = Regexp.last_match(3).strip
@@ -508,7 +516,7 @@ class CMockHeaderParser
           funcname.gsub!('const', '').strip!
           funconst = 'const '
         end
-        @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});"
+        parse_project[:typedefs] << "typedef #{funcret}(*#{functype})(#{funcargs});"
         funcname = "cmock_arg#{c += 1}" if funcname.empty?
         "#{functype} #{funconst}#{funcname}"
       end
@@ -525,7 +533,7 @@ class CMockHeaderParser
     end
   end
 
-  def parse_declaration(declaration, namespace = [], classname = nil)
+  def parse_declaration(parse_project, declaration, namespace = [], classname = nil)
     decl = {}
     decl[:namespace] = namespace
     decl[:class] = classname
@@ -568,20 +576,20 @@ 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
     else
       decl[:var_arg] = nil
     end
-    args = clean_args(args)
+    args = clean_args(args, parse_project)
     decl[:args_string] = args
     decl[:args] = parse_args(args)
     decl[:args_call] = decl[:args].map { |a| a[:name] }.join(', ')
@@ -602,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
 
@@ -611,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

data/vendor/cmock/src/cmock.c

@@ -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
+========================================================================= */
+
 /* ==========================================
     CMock Project - Automatic Mock Generation for C
     Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
@@ -25,8 +32,9 @@ static unsigned char*         CMock_Guts_Buffer = NULL;
 static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
 static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #else
-static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
+static long long              CMock_Guts_Space[(CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE + sizeof(long long) - 1) / sizeof(long long)];
+static unsigned char*         CMock_Guts_Buffer = (unsigned char *)CMock_Guts_Space;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;//sizeof(CMock_Guts_Space);
 static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #endif
 
@@ -39,12 +47,16 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
 
   /* verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere) */
   if (size < 1)
+  {
     return CMOCK_GUTS_NONE;
+  }
 
   /* verify we have enough room */
   size = size + CMOCK_MEM_INDEX_SIZE;
   if (size & CMOCK_MEM_ALIGN_MASK)
+  {
     size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
+  }
   if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
   {
 #ifndef CMOCK_MEM_DYNAMIC
@@ -103,9 +115,13 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_
     do {
       index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
       if (index >= CMock_Guts_FreePtr)
+      {
         return CMOCK_GUTS_NONE;
+      }
       if (index > 0)
+      {
         next = (void*)(&CMock_Guts_Buffer[index]);
+      }
     } while (index > 0);
     *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = (CMOCK_MEM_INDEX_TYPE)((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
     return root_index;
@@ -122,16 +138,22 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index
 
   /* There is nothing "next" if the pointer isn't from our buffer */
   if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
+  {
     return CMOCK_GUTS_NONE;
+  }
   previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
 
   /* if the pointer is good, then use it to look up the next index
    * (we know the first element always goes in zero, so NEXT must always be > 1) */
   index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
   if ((index > 1) && (index < CMock_Guts_FreePtr))
+  {
     return index;
+  }
   else
+  {
     return CMOCK_GUTS_NONE;
+  }
 }
 
 /*-------------------------------------------------------

data/vendor/cmock/src/cmock.h

@@ -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
+========================================================================= */
+
 /* ==========================================
     CMock Project - Automatic Mock Generation for C
     Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
@@ -10,8 +17,8 @@
 #include "cmock_internals.h"
 
 #define CMOCK_VERSION_MAJOR    2
-#define CMOCK_VERSION_MINOR    5
-#define CMOCK_VERSION_BUILD    3
+#define CMOCK_VERSION_MINOR    6
+#define CMOCK_VERSION_BUILD    0
 #define CMOCK_VERSION          ((CMOCK_VERSION_MAJOR << 16) | (CMOCK_VERSION_MINOR << 8) | CMOCK_VERSION_BUILD)
 
 /* should be big enough to index full range of CMOCK_MEM_MAX */

data/vendor/cmock/src/cmock_internals.h

@@ -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
+========================================================================= */
+
 /* ==========================================
     CMock Project - Automatic Mock Generation for C
     Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams