acpc_dealer 2.1.2 → 2.1.3

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_config.rb

@@ -1,129 +0,0 @@
-# ==========================================
-#   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 CMockConfig
-  
-  CMockDefaultOptions = 
-  {
-    :framework                => :unity,
-    :mock_path                => 'mocks',
-    :mock_prefix              => 'Mock',
-    :plugins                  => [],
-    :strippables              => ['(?:__attribute__\s*\(+.*?\)+)'],
-    :attributes               => ['__ramfunc', '__irq', '__fiq', 'register', 'extern'],
-    :c_calling_conventions    => ['__stdcall', '__cdecl', '__fastcall'],
-    :enforce_strict_ordering  => false,
-    :unity_helper_path        => false,
-    :treat_as                 => {},
-    :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
-    :ignore                   => :args_and_calls, #the options being :args_and_calls or :args_only
-    :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
-  }
-  
-  def initialize(options=nil)
-    case(options)
-      when NilClass then options = CMockDefaultOptions.clone 
-      when String   then options = CMockDefaultOptions.clone.merge(load_config_file_from_yaml(options))
-      when Hash     then options = CMockDefaultOptions.clone.merge(options)
-      else          raise "If you specify arguments, it should be a filename or a hash of options"
-    end
-    
-    #do some quick type verification
-    [:plugins, :attributes, :treat_as_void].each do |opt|
-      unless (options[opt].class == Array)
-        options[opt] = []
-        puts "WARNING: :#{opt.to_s} should be an array." unless (options[:verbosity] < 1)
-      end
-    end
-    [: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? or (options[opt].class == Array))
-        options[opt] = []
-        puts "WARNING: :#{opt.to_s} should be an array." unless (options[:verbosity] < 1)
-      end
-    end
-    options[:unity_helper_path] ||= options[:unity_helper]
-    options[:plugins].compact!
-    options[:plugins].map! {|p| p.to_sym}
-    @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 { |key| eval("def #{key.to_s}() return @options[:#{key.to_s}] end") }
-  end
-  
-  def load_config_file_from_yaml yaml_filename
-    require 'yaml'
-    require 'fileutils'
-    YAML.load_file(yaml_filename)[:cmock]
-  end
-  
-  def set_path(path)
-    @src_path = path
-  end
-  
-  def load_unity_helper
-    return File.new(@options[:unity_helper_path]).read if (@options[:unity_helper_path])
-    return nil
-  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*'           => 'PTR',
-      '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',
-      'pCHAR'           => 'STRING',
-      'cstring'         => 'STRING',
-      'CSTRING'         => 'STRING',
-      'float'           => 'FLOAT',
-      'double'          => 'FLOAT'
-    }
-  end
-end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_file_writer.rb

@@ -1,33 +0,0 @@
-# ==========================================
-#   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 CMockFileWriter
-
-  attr_reader :config
-
-  def initialize(config)
-    @config = config
-  end
-
-  def create_file(filename)
-    raise "Where's the block of data to create?" unless block_given?
-    full_file_name_temp = "#{@config.mock_path}/#{filename}.new"
-    full_file_name_done = "#{@config.mock_path}/#{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
-  
-  private ###################################
-  
-  def update_file(dest, src)
-    require 'fileutils'
-    FileUtils.rm(dest) if (File.exist?(dest))
-    FileUtils.cp(src, dest)
-    FileUtils.rm(src)
-  end
-end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_generator.rb

@@ -1,195 +0,0 @@
-# ==========================================
-#   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]
-# ========================================== 
-
-$here = File.dirname __FILE__
-
-class CMockGenerator
-
-  attr_accessor :config, :file_writer, :module_name, :clean_mock_name, :mock_name, :utils, :plugins, :ordered
-  
-  def initialize(config, file_writer, utils, plugins)
-    @file_writer = file_writer
-    @utils       = utils
-    @plugins     = plugins
-    @config      = config
-    @prefix      = @config.mock_prefix
-    @ordered     = @config.enforce_strict_ordering
-    @framework   = @config.framework.to_s
-    
-    @includes_h_pre_orig_header  = (@config.includes || @config.includes_h_pre_orig_header || []).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}\""}
-  end
-
-  def create_mock(module_name, parsed_stuff)
-    @module_name = module_name
-    @mock_name   = @prefix + @module_name
-    @clean_mock_name = @mock_name.gsub(/(?:-|\s+)/, "_")
-    create_mock_header_file(parsed_stuff)
-    create_mock_source_file(parsed_stuff)
-  end
-  
-  private if $ThisIsOnlyATest.nil? ##############################
-  
-  def create_mock_header_file(parsed_stuff)
-    @file_writer.create_file(@mock_name + ".h") do |file, filename|
-      create_mock_header_header(file, filename)
-      create_mock_header_service_call_declarations(file)
-      create_typedefs(file, parsed_stuff[:typedefs])
-      parsed_stuff[:functions].each do |function|
-        file << @plugins.run(:mock_function_declarations, function)
-      end
-      create_mock_header_footer(file)
-    end
-  end
-
-  def create_mock_source_file(parsed_stuff)
-    @file_writer.create_file(@mock_name + ".c") do |file, filename|
-      create_source_header_section(file, filename)
-      create_instance_structure(file, parsed_stuff[:functions])
-      create_extern_declarations(file)
-      create_mock_verify_function(file, parsed_stuff[:functions])
-      create_mock_init_function(file)
-      create_mock_destroy_function(file, parsed_stuff[:functions])
-      parsed_stuff[:functions].each do |function|
-        create_mock_implementation(file, function)
-        create_mock_interfaces(file, function)
-      end
-    end
-  end
-  
-  def create_mock_header_header(file, filename) 
-    define_name   = @clean_mock_name.gsub(/\.h/, "_h").upcase
-    orig_filename = filename.gsub(@config.mock_prefix, "")   
-    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
-    file << "#ifndef _#{define_name}_H\n"
-    file << "#define _#{define_name}_H\n\n"
-    @includes_h_pre_orig_header.each {|inc| file << "#include #{inc}\n"} 
-    file << "#include \"#{orig_filename}\"\n"
-    @includes_h_post_orig_header.each {|inc| file << "#include #{inc}\n"}
-    plugin_includes = @plugins.run(:include_files)
-    file << plugin_includes if (!plugin_includes.empty?)
-    file << "\n"
-  end
-  
-  def create_typedefs(file, typedefs)
-    file << "\n"
-    typedefs.each {|typedef| file << "#{typedef}\n" }
-    file << "\n\n"
-  end
-
-  def create_mock_header_service_call_declarations(file) 
-    file << "void #{@clean_mock_name}_Init(void);\n"
-    file << "void #{@clean_mock_name}_Destroy(void);\n"
-    file << "void #{@clean_mock_name}_Verify(void);\n\n"
-  end
-
-  def create_mock_header_footer(header)
-    header << "\n#endif\n"
-  end
-  
-  def create_source_header_section(file, filename)
-    header_file = filename.gsub(".c",".h")
-    file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
-    file << "#include <string.h>\n"
-    file << "#include <stdlib.h>\n"
-    file << "#include <setjmp.h>\n"
-    file << "#include \"#{@framework}.h\"\n"
-    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"
-  end
-  
-  def create_instance_structure(file, 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 #{@clean_mock_name}Instance\n{\n"
-    if (functions.size == 0)
-      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)
-    file << "extern jmp_buf AbortFrame;\n"
-    if (@ordered)
-      file << "extern int GlobalExpectCount;\n"
-      file << "extern int GlobalVerifyOrder;\n"
-    end
-    file << "\n"
-  end
-  
-  def create_mock_verify_function(file, functions)
-    file << "void #{@clean_mock_name}_Verify(void)\n{\n"
-    verifications = functions.collect {|function| @plugins.run(:mock_verify, function)}.join
-    file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n" unless verifications.empty?
-    file << verifications
-    file << "}\n\n"
-  end
-  
-  def create_mock_init_function(file)
-    file << "void #{@clean_mock_name}_Init(void)\n{\n"
-    file << "  #{@clean_mock_name}_Destroy();\n"
-    file << "}\n\n"
-  end
-  
-  def create_mock_destroy_function(file, functions)
-    file << "void #{@clean_mock_name}_Destroy(void)\n{\n"
-    file << "  CMock_Guts_MemFreeAll();\n"
-    file << "  memset(&Mock, 0, sizeof(Mock));\n"
-    file << functions.collect {|function| @plugins.run(:mock_destroy, function)}.join
-    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?)
-    
-    # Create mock function
-    file << "#{function_mod_and_rettype} #{function[: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 = (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, \"Function '#{function[:name]}' called more times than expected.\");\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, \"Function '#{function[:name]}' called earlier than expected.\");\n"
-      file << "  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)\n"
-      file << "    UNITY_TEST_FAIL(cmock_line, \"Function '#{function[:name]}' called later than expected.\");\n"
-      # file << "  UNITY_TEST_ASSERT((cmock_call_instance->CallOrder == ++GlobalVerifyOrder), cmock_line, \"Out of order function calls. Function '#{function[:name]}'\");\n"
-    end
-    file << @plugins.run(:mock_implementation, function)
-    file << "  return cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?]) 
-    file << "}\n\n"
-  end
-  
-  def create_mock_interfaces(file, function)
-    file << @utils.code_add_argument_loader(function)
-    file << @plugins.run(:mock_interfaces, function)
-  end
-end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_generator_plugin_array.rb

@@ -1,57 +0,0 @@
-# ==========================================
-#   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 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   = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : "#{m[:name]}"}.join(', ')
-    args_string = function[:args].map{|m| m[:ptr?] ? "#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{m[:type]} #{m[:name]}"}.join(', ')
-    if (function[:return][:void?])
-      return "#define #{function[:name]}_ExpectWithArray(#{args_call}) #{function[:name]}_CMockExpectWithArray(__LINE__, #{args_call})\n" +
-             "void #{function[:name]}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string});\n"
-    else
-      return "#define #{function[:name]}_ExpectWithArrayAndReturn(#{args_call}, cmock_retval) #{function[:name]}_CMockExpectWithArrayAndReturn(__LINE__, #{args_call}, 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{|m| m[:ptr?] ? "#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{m[:type]} #{m[:name]}"}.join(', ')
-    call_string = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : m[:name]}.join(', ')
-    if (function[:return][:void?])
-      lines << "void #{func_name}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, #{args_string})\n"
-    else
-      lines << "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

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/lib/cmock_generator_plugin_callback.rb

@@ -1,78 +0,0 @@
-# ==========================================
-#   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 CMockGeneratorPluginCallback
-
-  attr_accessor :include_count
-  attr_reader :priority
-  attr_reader :config, :utils
-  
-  def initialize(config, utils)
-    @config = config
-    @utils = utils
-    @priority = 6
-    
-    @include_count = @config.callback_include_count
-    if (@config.callback_after_arg_check)
-      alias :mock_implementation          :mock_implementation_for_callbacks
-      alias :mock_implementation_precheck :nothing
-    else
-      alias :mock_implementation_precheck :mock_implementation_for_callbacks
-      alias :mock_implementation          :nothing
-    end
-  end
-
-  def instance_structure(function)
-    func_name = function[:name]
-    "  CMOCK_#{func_name}_CALLBACK #{func_name}_CallbackFunctionPointer;\n" +
-    "  int #{func_name}_CallbackCalls;\n"
-  end
-
-  def mock_function_declarations(function)
-    func_name = function[:name]
-    return_type = function[:return][:const?] ? "const #{function[:return][:type]}" : function[:return][:type]
-    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2)
-    styles = [ "void", "int cmock_num_calls", function[:args_string], "#{function[:args_string]}, int cmock_num_calls" ]
-    "typedef #{return_type} (* CMOCK_#{func_name}_CALLBACK)(#{styles[style]});\nvoid #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback);\n"
-  end
-
-  def mock_implementation_for_callbacks(function)
-    func_name   = function[:name]
-    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
-    case(style)
-      when 0 then "    Mock.#{func_name}_CallbackFunctionPointer();\n    return;\n  }\n"
-      when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
-      when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n    return;\n  }\n"
-      when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
-      when 4 then "    return Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 5 then "    return Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 6 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 7 then "    return Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
-    end
-  end
-  
-  def nothing(function)
-    return ""
-  end
-
-  def mock_interfaces(function)
-    func_name = function[:name]
-    "void #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback)\n{\n" + 
-    "  Mock.#{func_name}_CallbackFunctionPointer = Callback;\n}\n\n"
-  end
-
-  def mock_destroy(function)
-    "  Mock.#{function[:name]}_CallbackFunctionPointer = NULL;\n" +
-    "  Mock.#{function[:name]}_CallbackCalls = 0;\n"
-  end
-  
-  def mock_verify(function)
-    func_name = function[:name]
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
-  end
-
-end