ceedling 0.9.0 → 1.0.1

data/vendor/cmock/lib/cmock_config.rb

@@ -0,0 +1,184 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class CMockConfig
+  CMOCK_DEFAULT_OPTIONS =
+    {
+      :framework                   => :unity,
+      :mock_path                   => 'mocks',
+      :mock_prefix                 => 'Mock',
+      :mock_suffix                 => '',
+      :skeleton_path               => '',
+      :weak                        => '',
+      :subdir                      => nil,
+      :plugins                     => [],
+      :strippables                 => ['(?:__attribute__\s*\([ (]*.*?[ )]*\)+)'],
+      :attributes                  => %w[__ramfunc __irq __fiq register extern],
+      :c_calling_conventions       => %w[__stdcall __cdecl __fastcall],
+      :enforce_strict_ordering     => false,
+      :fail_on_unexpected_calls    => true,
+      :unity_helper_path           => false,
+      :treat_as                    => {},
+      :treat_as_array              => {},
+      :treat_as_void               => [],
+      :memcmp_if_unknown           => true,
+      :when_no_prototypes          => :warn,           # the options being :ignore, :warn, or :error
+      :when_ptr                    => :compare_data,   # the options being :compare_ptr, :compare_data, or :smart
+      :verbosity                   => 2,               # the options being 0 errors only, 1 warnings and errors, 2 normal info, 3 verbose
+      :treat_externs               => :exclude,        # the options being :include or :exclude
+      :treat_inlines               => :exclude,        # the options being :include or :exclude
+      :callback_include_count      => true,
+      :callback_after_arg_check    => false,
+      :includes                    => nil,
+      :includes_h_pre_orig_header  => nil,
+      :includes_h_post_orig_header => nil,
+      :includes_c_pre_header       => nil,
+      :includes_c_post_header      => nil,
+      :orig_header_include_fmt     => '#include "%s"',
+      :array_size_type             => [],
+      :array_size_name             => 'size|len',
+      :skeleton                    => false,
+      :exclude_setjmp_h            => false,
+
+      # Format to look for inline functions.
+      # This is a combination of "static" and "inline" keywords ("static inline", "inline static", "inline", "static")
+      # There are several possibilities:
+      # - sometimes they appear together, sometimes individually,
+      # - The keywords can appear before or after the return type (this is a compiler warning but people do weird stuff),
+      #   so we check for word boundaries when searching for them
+      # - We first remove "static inline" combinations and boil down to single inline or static statements
+      :inline_function_patterns    => ['(static\s+inline|inline\s+static)\s*', '(\binline\b)\s*', '(?:static\s*)?(?:__inline__)?__attribute__\s*\([ (]*always_inline[ )]*\)', 'static __inline__'] # Last part (\s*) is just to remove whitespaces (only to prettify the output)
+    }.freeze
+
+  def initialize(options = nil)
+    case options
+    when NilClass then options = CMOCK_DEFAULT_OPTIONS.dup
+    when String   then options = CMOCK_DEFAULT_OPTIONS.dup.merge(load_config_file_from_yaml(options))
+    when Hash     then options = CMOCK_DEFAULT_OPTIONS.dup.merge(options)
+    else raise 'If you specify arguments, it should be a filename or a hash of options'
+    end
+
+    # do some quick type verification
+    %i[plugins attributes treat_as_void].each do |opt|
+      unless options[opt].instance_of?(Array)
+        options[opt] = []
+        puts "WARNING: :#{opt} should be an array." unless options[:verbosity] < 1
+      end
+    end
+    %i[includes includes_h_pre_orig_header includes_h_post_orig_header includes_c_pre_header includes_c_post_header].each do |opt|
+      unless options[opt].nil? || options[opt].instance_of?(Array)
+        options[opt] = []
+        puts "WARNING: :#{opt} should be an array." unless options[:verbosity] < 1
+      end
+    end
+    options[:unity_helper_path] ||= options[:unity_helper]
+    options[:unity_helper_path] = [options[:unity_helper_path]] if options[:unity_helper_path].is_a? String
+
+    if options[:unity_helper_path]
+      require 'pathname'
+      includes1 = options[:includes_c_post_header] || []
+      includes2 = options[:unity_helper_path].map do |path|
+        Pathname(File.expand_path(path)).relative_path_from(Pathname(File.expand_path(options[:mock_path]))).to_s
+      rescue StandardError
+        path
+      end
+      options[:includes_c_post_header] = (includes1 + includes2).uniq
+    end
+
+    options[:plugins].compact!
+    options[:plugins].map!(&:to_sym)
+
+    raise 'The :ignore plugin is required to disable :fail_on_unexpected_calls' if (!options[:plugins].include? :ignore) && (!options[:fail_on_unexpected_calls])
+
+    @options = options
+
+    treat_as_map = standard_treat_as_map # .clone
+    treat_as_map.merge!(@options[:treat_as])
+    @options[:treat_as] = treat_as_map
+
+    @options.each_key do |key|
+      unless methods.include?(key)
+        eval("def #{key}() return @options[:#{key}] end")
+      end
+    end
+  end
+
+  def load_config_file_from_yaml(yaml_filename)
+    self.class.load_config_file_from_yaml yaml_filename
+  end
+
+  def self.load_config_file_from_yaml(yaml_filename)
+    require 'yaml'
+    require 'fileutils'
+    begin
+      YAML.load_file(yaml_filename, aliases: true)[:cmock]
+    rescue ArgumentError
+      YAML.load_file(yaml_filename)[:cmock]
+    end
+  end
+
+  def path(new_path)
+    @src_path = new_path
+  end
+
+  def load_unity_helper
+    return nil unless @options[:unity_helper_path]
+
+    @options[:unity_helper_path].inject('') do |unity_helper, filename|
+      unity_helper + "\n#{File.new(filename).read}"
+    end
+  end
+
+  def standard_treat_as_map
+    {
+      'int'             => 'INT',
+      'char'            => 'INT8',
+      'short'           => 'INT16',
+      'long'            => 'INT',
+      'int8'            => 'INT8',
+      'int16'           => 'INT16',
+      'int32'           => 'INT',
+      'int8_t'          => 'INT8',
+      'int16_t'         => 'INT16',
+      'int32_t'         => 'INT',
+      'INT8_T'          => 'INT8',
+      'INT16_T'         => 'INT16',
+      'INT32_T'         => 'INT',
+      'bool'            => 'INT',
+      'bool_t'          => 'INT',
+      'BOOL'            => 'INT',
+      'BOOL_T'          => 'INT',
+      'unsigned int'    => 'HEX32',
+      'unsigned long'   => 'HEX32',
+      'uint32'          => 'HEX32',
+      'uint32_t'        => 'HEX32',
+      'UINT32'          => 'HEX32',
+      'UINT32_T'        => 'HEX32',
+      'void*'           => 'HEX8_ARRAY',
+      'void const*'     => 'HEX8_ARRAY',
+      'const void*'     => 'HEX8_ARRAY',
+      'unsigned short'  => 'HEX16',
+      'uint16'          => 'HEX16',
+      'uint16_t'        => 'HEX16',
+      'UINT16'          => 'HEX16',
+      'UINT16_T'        => 'HEX16',
+      'unsigned char'   => 'HEX8',
+      'uint8'           => 'HEX8',
+      'uint8_t'         => 'HEX8',
+      'UINT8'           => 'HEX8',
+      'UINT8_T'         => 'HEX8',
+      'char*'           => 'STRING',
+      'char const*'     => 'STRING',
+      'const char*'     => 'STRING',
+      'pCHAR'           => 'STRING',
+      'cstring'         => 'STRING',
+      'CSTRING'         => 'STRING',
+      'float'           => 'FLOAT',
+      'double'          => 'FLOAT'
+    }
+  end
+end

data/vendor/cmock/lib/cmock_file_writer.rb

@@ -0,0 +1,48 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class CMockFileWriter
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+  end
+
+  def create_subdir(subdir)
+    require 'fileutils'
+    FileUtils.mkdir_p "#{@config.mock_path}/" unless Dir.exist?("#{@config.mock_path}/")
+    FileUtils.mkdir_p "#{@config.mock_path}/#{"#{subdir}/" if subdir}" if subdir && !Dir.exist?("#{@config.mock_path}/#{"#{subdir}/" if subdir}")
+  end
+
+  def create_file(filename, subdir)
+    raise "Where's the block of data to create?" unless block_given?
+
+    full_file_name_temp = "#{@config.mock_path}/#{"#{subdir}/" if subdir}#{filename}.new"
+    full_file_name_done = "#{@config.mock_path}/#{"#{subdir}/" if subdir}#{filename}"
+    File.open(full_file_name_temp, 'w') do |file|
+      yield(file, filename)
+    end
+    update_file(full_file_name_done, full_file_name_temp)
+  end
+
+  def append_file(filename, subdir)
+    raise "Where's the block of data to create?" unless block_given?
+
+    full_file_name = "#{@config.skeleton_path}/#{"#{subdir}/" if subdir}#{filename}"
+    File.open(full_file_name, 'a') do |file|
+      yield(file, filename)
+    end
+  end
+
+  private ###################################
+
+  def update_file(dest, src)
+    require 'fileutils'
+    FileUtils.rm(dest, :force => true)
+    FileUtils.mv(src, dest)
+  end
+end

data/vendor/cmock/lib/cmock_generator.rb

@@ -0,0 +1,379 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class CMockGenerator
+  attr_accessor :config, :file_writer, :module_name, :module_ext, :clean_mock_name, :mock_name, :utils, :plugins, :weak, :ordered
+
+  def initialize(config, file_writer, utils, plugins)
+    @file_writer = file_writer
+    @utils       = utils
+    @plugins     = plugins
+    @config      = config
+    @prefix      = @config.mock_prefix
+    @suffix      = @config.mock_suffix
+    @weak        = @config.weak
+    @include_inline = @config.treat_inlines
+    @ordered = @config.enforce_strict_ordering
+    @framework = @config.framework.to_s
+    @fail_on_unexpected_calls = @config.fail_on_unexpected_calls
+    @exclude_setjmp_h = @config.exclude_setjmp_h
+    @subdir = @config.subdir
+
+    @includes_h_pre_orig_header  = ((@config.includes || []) + (@config.includes_h_pre_orig_header || [])).uniq.map { |h| h =~ /</ ? h : "\"#{h}\"" }
+    @includes_h_post_orig_header = (@config.includes_h_post_orig_header || []).map { |h| h =~ /</ ? h : "\"#{h}\"" }
+    @includes_c_pre_header       = (@config.includes_c_pre_header || []).map { |h| h =~ /</ ? h : "\"#{h}\"" }
+    @includes_c_post_header      = (@config.includes_c_post_header || []).map { |h| h =~ /</ ? h : "\"#{h}\"" }
+
+    here = File.dirname __FILE__
+    unity_path_in_ceedling = "#{here}/../../unity" # path to Unity from within Ceedling
+    unity_path_in_cmock = "#{here}/../vendor/unity" # path to Unity from within CMock
+    # path to Unity as specified by env var
+    unity_path_in_env = ENV.key?('UNITY_DIR') ? File.expand_path(ENV.fetch('UNITY_DIR')) : nil
+
+    if unity_path_in_env && File.exist?(unity_path_in_env)
+      require "#{unity_path_in_env}/auto/type_sanitizer"
+    elsif File.exist? unity_path_in_ceedling
+      require "#{unity_path_in_ceedling}/auto/type_sanitizer"
+    elsif File.exist? unity_path_in_cmock
+      require "#{unity_path_in_cmock}/auto/type_sanitizer"
+    else
+      raise 'Failed to find an instance of Unity to pull in type_sanitizer module!'
+    end
+  end
+
+  def create_mock(module_name, parsed_stuff, module_ext = nil, folder = nil)
+    # determine the name for our new mock
+    mock_name = @prefix + module_name + @suffix
+
+    # determine the folder our mock will reside
+    mock_folder = if folder && @subdir
+                    File.join(@subdir, folder)
+                  elsif @subdir
+                    @subdir
+                  else
+                    folder
+                  end
+
+    # adds a trailing slash to the folder output
+    mock_folder = File.join(mock_folder, '') if mock_folder
+
+    # create out mock project from incoming data
+    mock_project = {
+      :module_name  => module_name,
+      :module_ext   => (module_ext || '.h'),
+      :mock_name    => mock_name,
+      :clean_name   => TypeSanitizer.sanitize_c_identifier(mock_name),
+      :folder       => mock_folder,
+      :parsed_stuff => parsed_stuff,
+      :skeleton     => false
+    }
+
+    create_mock_subdir(mock_project)
+    create_mock_header_file(mock_project)
+    create_mock_source_file(mock_project)
+  end
+
+  def create_skeleton(module_name, parsed_stuff)
+    mock_project = {
+      :module_name  => module_name,
+      :module_ext   => '.h',
+      :parsed_stuff => parsed_stuff,
+      :skeleton     => true
+    }
+
+    create_skeleton_source_file(mock_project)
+  end
+
+  private if $ThisIsOnlyATest.nil? ##############################
+
+  def create_mock_subdir(mock_project)
+    @file_writer.create_subdir(mock_project[:folder])
+  end
+
+  def create_using_statement(file, function)
+    file << "using namespace #{function[:namespace].join('::')};\n" unless function[:namespace].empty?
+  end
+
+  def create_mock_header_file(mock_project)
+    if @include_inline == :include
+      @file_writer.create_file(mock_project[:module_name] + (mock_project[:module_ext]), mock_project[:folder]) do |file, _filename|
+        file << mock_project[:parsed_stuff][:normalized_source]
+      end
+    end
+
+    @file_writer.create_file(mock_project[:mock_name] + mock_project[:module_ext], mock_project[:folder]) do |file, filename|
+      create_mock_header_header(file, filename, mock_project)
+      create_mock_header_service_call_declarations(file, mock_project)
+      create_typedefs(file, mock_project)
+      mock_project[:parsed_stuff][:functions].each do |function|
+        create_using_statement(file, function)
+        file << @plugins.run(:mock_function_declarations, function)
+      end
+      create_mock_header_footer(file)
+    end
+  end
+
+  def create_mock_source_file(mock_project)
+    @file_writer.create_file("#{mock_project[:mock_name]}.c", mock_project[:folder]) do |file, filename|
+      create_source_header_section(file, filename, mock_project)
+      create_instance_structure(file, mock_project)
+      create_extern_declarations(file)
+      create_mock_verify_function(file, mock_project)
+      create_mock_init_function(file, mock_project)
+      create_mock_destroy_function(file, mock_project)
+      mock_project[:parsed_stuff][:functions].each do |function|
+        create_mock_implementation(file, function)
+        create_mock_interfaces(file, function)
+      end
+    end
+  end
+
+  def create_skeleton_source_file(mock_project)
+    filename = "#{@config.mock_path}/#{"#{@subdir}/" if @subdir}#{mock_project[:module_name]}.c"
+    existing = File.exist?(filename) ? File.read(filename) : ''
+    @file_writer.create_file("#{mock_project[:module_name]}.c", @subdir) do |file, fullname|
+      blank_project = mock_project.clone
+      blank_project[:parsed_stuff] = { :functions => [] }
+      if existing.empty?
+        create_source_header_section(file, fullname, blank_project)
+      else
+        file << existing
+        file << "\n" if existing[-1] != "\n"
+      end
+      mock_project[:parsed_stuff][:functions].each do |function|
+        create_function_skeleton(file, function, existing)
+      end
+    end
+  end
+
+  def create_mock_header_header(file, _filename, mock_project)
+    define_name = mock_project[:clean_name].upcase
+    orig_filename = (mock_project[:folder] || '') + mock_project[:module_name] + mock_project[:module_ext]
+    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
+    file << "#ifndef _#{define_name}_H\n"
+    file << "#define _#{define_name}_H\n\n"
+    file << "#include \"#{@framework}.h\"\n"
+    @includes_h_pre_orig_header.each { |inc| file << "#include #{inc}\n" }
+    file << "#{@config.orig_header_include_fmt.gsub(/%s/, orig_filename.to_s)}\n"
+    @includes_h_post_orig_header.each { |inc| file << "#include #{inc}\n" }
+    plugin_includes = @plugins.run(:include_files)
+    file << plugin_includes unless plugin_includes.empty?
+    file << "\n"
+    file << "/* Ignore the following warnings, since we are copying code */\n"
+    file << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    file << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
+    file << "#pragma GCC diagnostic push\n"
+    file << "#endif\n"
+    file << "#if !defined(__clang__)\n"
+    file << "#pragma GCC diagnostic ignored \"-Wpragmas\"\n"
+    file << "#endif\n"
+    file << "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n"
+    file << "#pragma GCC diagnostic ignored \"-Wduplicate-decl-specifier\"\n"
+    file << "#endif\n"
+    file << "\n"
+    file << "#ifdef __cplusplus\n"
+    file << "extern \"C\" {\n"
+    file << "#endif\n"
+    file << "\n"
+  end
+
+  def create_typedefs(file, mock_project)
+    file << "\n"
+    mock_project[:parsed_stuff][:typedefs].each { |typedef| file << "#{typedef}\n" }
+    file << "\n\n"
+  end
+
+  def create_mock_header_service_call_declarations(file, mock_project)
+    file << "void #{mock_project[:clean_name]}_Init(void);\n"
+    file << "void #{mock_project[:clean_name]}_Destroy(void);\n"
+    file << "void #{mock_project[:clean_name]}_Verify(void);\n\n"
+  end
+
+  def create_mock_header_footer(header)
+    header << "\n"
+    header << "#ifdef __cplusplus\n"
+    header << "}\n"
+    header << "#endif\n"
+    header << "\n"
+    header << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    header << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
+    header << "#pragma GCC diagnostic pop\n"
+    header << "#endif\n"
+    header << "#endif\n"
+    header << "\n"
+    header << "#endif\n"
+  end
+
+  def create_source_header_section(file, filename, mock_project)
+    header_file = (mock_project[:folder] || '') + filename.sub(/.*\K\.c/, mock_project[:module_ext])
+    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n" unless mock_project[:parsed_stuff][:functions].empty?
+    file << "#include <string.h>\n"
+    file << "#include <stdlib.h>\n"
+    unless @exclude_setjmp_h
+      file << "#include <setjmp.h>\n"
+    end
+    file << "#include \"cmock.h\"\n"
+    @includes_c_pre_header.each { |inc| file << "#include #{inc}\n" }
+    file << "#include \"#{header_file}\"\n"
+    @includes_c_post_header.each { |inc| file << "#include #{inc}\n" }
+    file << "\n"
+    strs = []
+    mock_project[:parsed_stuff][:functions].each do |func|
+      strs << func[:name]
+      func[:args].each { |arg| strs << arg[:name] }
+    end
+    strs.uniq.sort.each do |str|
+      file << "static const char* CMockString_#{str} = \"#{str}\";\n"
+    end
+    file << "\n"
+  end
+
+  def create_instance_structure(file, mock_project)
+    functions = mock_project[:parsed_stuff][:functions]
+    functions.each do |function|
+      file << "typedef struct _CMOCK_#{function[:name]}_CALL_INSTANCE\n{\n"
+      file << "  UNITY_LINE_TYPE LineNumber;\n"
+      file << @plugins.run(:instance_typedefs, function)
+      file << "\n} CMOCK_#{function[:name]}_CALL_INSTANCE;\n\n"
+    end
+    file << "static struct #{mock_project[:clean_name]}Instance\n{\n"
+    if functions.empty?
+      file << "  unsigned char placeHolder;\n"
+    end
+    functions.each do |function|
+      file << @plugins.run(:instance_structure, function)
+      file << "  CMOCK_MEM_INDEX_TYPE #{function[:name]}_CallInstance;\n"
+    end
+    file << "} Mock;\n\n"
+  end
+
+  def create_extern_declarations(file)
+    if @ordered
+      file << "extern int GlobalExpectCount;\n"
+      file << "extern int GlobalVerifyOrder;\n"
+    end
+    file << "\n"
+  end
+
+  def create_mock_verify_function(file, mock_project)
+    file << "void #{mock_project[:clean_name]}_Verify(void)\n{\n"
+    verifications = mock_project[:parsed_stuff][:functions].collect do |function|
+      v = @plugins.run(:mock_verify, function)
+      v.empty? ? v : ["  call_instance = Mock.#{function[:name]}_CallInstance;\n", v]
+    end.join
+    unless verifications.empty?
+      file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n"
+      file << "  CMOCK_MEM_INDEX_TYPE call_instance;\n"
+      file << verifications
+    end
+    file << "}\n\n"
+  end
+
+  def create_mock_init_function(file, mock_project)
+    file << "void #{mock_project[:clean_name]}_Init(void)\n{\n"
+    file << "  #{mock_project[:clean_name]}_Destroy();\n"
+    file << "}\n\n"
+  end
+
+  def create_mock_destroy_function(file, mock_project)
+    file << "void #{mock_project[:clean_name]}_Destroy(void)\n{\n"
+    file << "  CMock_Guts_MemFreeAll();\n"
+    file << "  memset(&Mock, 0, sizeof(Mock));\n"
+    file << mock_project[:parsed_stuff][:functions].collect { |function| @plugins.run(:mock_destroy, function) }.join
+
+    unless @fail_on_unexpected_calls
+      file << mock_project[:parsed_stuff][:functions].collect { |function| @plugins.run(:mock_ignore, function) }.join
+    end
+
+    if @ordered
+      file << "  GlobalExpectCount = 0;\n"
+      file << "  GlobalVerifyOrder = 0;\n"
+    end
+    file << "}\n\n"
+  end
+
+  def create_mock_implementation(file, function)
+    # prepare return value and arguments
+    function_mod_and_rettype = (function[:modifier].empty? ? '' : "#{function[:modifier]} ") +
+                               (function[:return][:type]) +
+                               (function[:c_calling_convention] ? " #{function[:c_calling_convention]}" : '')
+    args_string = function[:args_string]
+    args_string += ", #{function[:var_arg]}" unless function[:var_arg].nil?
+
+    # Encapsulate in namespace(s) if applicable
+    function[:namespace].each do |ns|
+      file << "namespace #{ns} {\n"
+    end
+
+    # Determine class prefix (if any)
+    cls_pre = ''
+    unless function[:class].nil?
+      cls_pre = "#{function[:class]}::"
+    end
+
+    # Create mock function
+    unless @weak.empty?
+      file << "#if defined (__IAR_SYSTEMS_ICC__)\n"
+      file << "#pragma weak #{function[:unscoped_name]}\n"
+      file << "#else\n"
+      file << "#{function_mod_and_rettype} #{function[:unscoped_name]}(#{args_string}) #{weak};\n"
+      file << "#endif\n\n"
+    end
+    file << "#{function_mod_and_rettype} #{cls_pre}#{function[:unscoped_name]}(#{args_string})\n"
+    file << "{\n"
+    file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n"
+    file << "  CMOCK_#{function[:name]}_CALL_INSTANCE* cmock_call_instance;\n"
+    file << "  UNITY_SET_DETAIL(CMockString_#{function[:name]});\n"
+    file << "  cmock_call_instance = (CMOCK_#{function[:name]}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.#{function[:name]}_CallInstance);\n"
+    file << "  Mock.#{function[:name]}_CallInstance = CMock_Guts_MemNext(Mock.#{function[:name]}_CallInstance);\n"
+    file << @plugins.run(:mock_implementation_precheck, function)
+    file << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);\n"
+    file << "  cmock_line = cmock_call_instance->LineNumber;\n"
+    if @ordered
+      file << "  if (cmock_call_instance->CallOrder > ++GlobalVerifyOrder)\n"
+      file << "    UNITY_TEST_FAIL(cmock_line, CMockStringCalledEarly);\n"
+      file << "  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)\n"
+      file << "    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);\n"
+    end
+    file << @plugins.run(:mock_implementation, function)
+    file << "  UNITY_CLR_DETAILS();\n"
+    file << "  return cmock_call_instance->ReturnVal;\n" unless function[:return][:void?]
+    file << "}\n"
+
+    # Close any namespace(s) opened above
+    function[:namespace].each do
+      file << "}\n"
+    end
+
+    file << "\n"
+  end
+
+  def create_mock_interfaces(file, function)
+    file << @utils.code_add_argument_loader(function)
+    file << @plugins.run(:mock_interfaces, function)
+  end
+
+  def create_function_skeleton(file, function, existing)
+    # prepare return value and arguments
+    function_mod_and_rettype = (function[:modifier].empty? ? '' : "#{function[:modifier]} ") +
+                               (function[:return][:type]) +
+                               (function[:c_calling_convention] ? " #{function[:c_calling_convention]}" : '')
+    args_string = function[:args_string]
+    args_string += ", #{function[:var_arg]}" unless function[:var_arg].nil?
+
+    decl = "#{function_mod_and_rettype} #{function[:name]}(#{args_string})"
+
+    return if existing.include?(decl)
+
+    file << "#{decl}\n"
+    file << "{\n"
+    file << "  /*TODO: Implement Me!*/\n"
+    function[:args].each { |arg| file << "  (void)#{arg[:name]};\n" }
+    file << "  return (#{function[:return][:type]})0;\n" unless function[:return][:void?]
+    file << "}\n\n"
+  end
+end

data/vendor/cmock/lib/cmock_generator_plugin_array.rb

@@ -0,0 +1,68 @@
+# =========================================================================
+#   CMock - Automatic Mock Generation for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class CMockGeneratorPluginArray
+  attr_reader :priority
+  attr_accessor :config, :utils, :unity_helper, :ordered
+
+  def initialize(config, utils)
+    @config       = config
+    @ptr_handling = @config.when_ptr
+    @ordered      = @config.enforce_strict_ordering
+    @utils        = utils
+    @unity_helper = @utils.helpers[:unity_helper]
+    @priority     = 8
+  end
+
+  def instance_typedefs(function)
+    function[:args].inject('') do |all, arg|
+      arg[:ptr?] ? all + "  int Expected_#{arg[:name]}_Depth;\n" : all
+    end
+  end
+
+  def mock_function_declarations(function)
+    return nil unless function[:contains_ptr?]
+
+    args_call_i = function[:args].map { |m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : (m[:name]).to_s }.join(', ')
+    args_call_o = function[:args].map { |m| m[:ptr?] ? "#{m[:name]}, (#{m[:name]}_Depth)" : (m[:name]).to_s }.join(', ')
+    args_string = function[:args].map do |m|
+      type = @utils.arg_type_with_const(m)
+      m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
+    end.join(', ')
+    if function[:return][:void?]
+      "#define #{function[:name]}_ExpectWithArrayAndReturn(#{args_call_i}, cmock_retval) TEST_FAIL_MESSAGE(\"#{function[:name]} requires _ExpectWithArray (not AndReturn)\");\n" \
+      "#define #{function[:name]}_ExpectWithArray(#{args_call_i}) #{function[:name]}_CMockExpectWithArray(__LINE__, #{args_call_o})\n" \
+      "void #{function[:name]}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string});\n"
+    else
+      "#define #{function[:name]}_ExpectWithArray(#{args_call_i}) TEST_FAIL_MESSAGE(\"#{function[:name]} requires _ExpectWithArrayAndReturn\");\n" \
+      "#define #{function[:name]}_ExpectWithArrayAndReturn(#{args_call_i}, cmock_retval) #{function[:name]}_CMockExpectWithArrayAndReturn(__LINE__, #{args_call_o}, cmock_retval)\n" \
+      "void #{function[:name]}_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, #{args_string}, #{function[:return][:str]});\n"
+    end
+  end
+
+  def mock_interfaces(function)
+    return nil unless function[:contains_ptr?]
+
+    lines = []
+    func_name = function[:name]
+    args_string = function[:args].map do |m|
+      type = @utils.arg_type_with_const(m)
+      m[:ptr?] ? "#{type} #{m[:name]}, int #{m[:name]}_Depth" : "#{type} #{m[:name]}"
+    end.join(', ')
+    call_string = function[:args].map { |m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : m[:name] }.join(', ')
+    lines << if function[:return][:void?]
+               "void #{func_name}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string})\n"
+             else
+               "void #{func_name}_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, #{args_string}, #{function[:return][:str]})\n"
+             end
+    lines << "{\n"
+    lines << @utils.code_add_base_expectation(func_name)
+    lines << "  CMockExpectParameters_#{func_name}(cmock_call_instance, #{call_string});\n"
+    lines << "  cmock_call_instance->ReturnVal = cmock_to_return;\n" unless function[:return][:void?]
+    lines << "}\n\n"
+  end
+end