From 67858837d17cff1227b6f56b2257706442c8e658 Mon Sep 17 00:00:00 2001 From: mvandervoord Date: Wed, 18 Mar 2020 19:16:58 -0400 Subject: [PATCH] Update coding style to match our own official coding guidelines --- config/production_environment.rb | 12 +- config/test_environment.rb | 2 +- examples/temp_sensor/rakefile.rb | 20 +- examples/temp_sensor/rakefile_helper.rb | 180 ++++++------ lib/cmock.rb | 45 ++- lib/cmock_config.rb | 129 +++++---- lib/cmock_file_writer.rb | 17 +- lib/cmock_generator.rb | 98 ++++--- lib/cmock_generator_plugin_array.rb | 30 +- lib/cmock_generator_plugin_callback.rb | 5 +- lib/cmock_generator_plugin_cexception.rb | 32 +-- lib/cmock_generator_plugin_expect.rb | 58 ++-- lib/cmock_generator_plugin_expect_any_args.rb | 33 ++- lib/cmock_generator_plugin_ignore.rb | 31 +- lib/cmock_generator_plugin_ignore_arg.rb | 10 +- lib/cmock_generator_plugin_return_thru_ptr.rb | 84 +++--- lib/cmock_generator_utils.rb | 240 ++++++++-------- lib/cmock_header_parser.rb | 270 +++++++++--------- lib/cmock_plugin_manager.rb | 39 ++- lib/cmock_unityhelper_parser.rb | 74 ++--- scripts/create_makefile.rb | 99 +++---- scripts/create_mock.rb | 4 +- scripts/create_runner.rb | 13 +- scripts/test_summary.rb | 3 +- test/rakefile | 33 +++ test/rakefile_helper.rb | 12 + test/unit/cmock_header_parser_test.rb | 2 +- 27 files changed, 797 insertions(+), 778 deletions(-) diff --git a/config/production_environment.rb b/config/production_environment.rb index 915582b..082b63f 100644 --- a/config/production_environment.rb +++ b/config/production_environment.rb @@ -2,13 +2,11 @@ # 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] -# ========================================== - +# ========================================== + # Setup our load path: -[ - 'lib', +[ + 'lib' ].each do |dir| - $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__)) + '/../', dir) ) + $:.unshift(File.join(__dir__ + '/../', dir)) end - - diff --git a/config/test_environment.rb b/config/test_environment.rb index fe1ed81..aeae3a3 100644 --- a/config/test_environment.rb +++ b/config/test_environment.rb @@ -12,5 +12,5 @@ './vendor/unity/auto/', './test/system/' ].each do |dir| - $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__) + "/../"), dir) ) + $:.unshift(File.join(File.expand_path(File.dirname(__FILE__) + '/../'), dir)) end diff --git a/examples/temp_sensor/rakefile.rb b/examples/temp_sensor/rakefile.rb index c902828..8d87293 100644 --- a/examples/temp_sensor/rakefile.rb +++ b/examples/temp_sensor/rakefile.rb @@ -1,4 +1,4 @@ -HERE = File.expand_path(File.dirname(__FILE__)) + '/' +HERE = __dir__ + '/' require 'rake' require 'rake/clean' @@ -7,36 +7,36 @@ require './rakefile_helper' include RakefileHelpers -REQUIRED_DIRS = [ './build', './build/mocks' ] +REQUIRED_DIRS = ['./build', './build/mocks'].freeze REQUIRED_DIRS.each do |v| directory v end # Load default configuration, for now -DEFAULT_CONFIG_FILE = 'gcc.yml' +DEFAULT_CONFIG_FILE = 'gcc.yml'.freeze configure_toolchain(DEFAULT_CONFIG_FILE) task :unit do run_tests(get_unit_test_files) end -desc "Generate test summary" +desc 'Generate test summary' task :summary do report_summary end -desc "Build and test Unity" -task :all => [:clean, :unit, :summary] -task :default => REQUIRED_DIRS + [:clobber, :all] +desc 'Build and test Unity' +task :all => %i[clean unit summary] +task :default => REQUIRED_DIRS + %i[clobber all] task :ci => [:default] task :cruise => [:default] -desc "Load configuration" -task :config, :config_file do |t, args| +desc 'Load configuration' +task :config, :config_file do |_t, args| configure_toolchain(args[:config_file]) end -desc "Return error on Failures" +desc 'Return error on Failures' task :strict do $return_error_on_failures = true end diff --git a/examples/temp_sensor/rakefile_helper.rb b/examples/temp_sensor/rakefile_helper.rb index ff3f089..021eb3a 100644 --- a/examples/temp_sensor/rakefile_helper.rb +++ b/examples/temp_sensor/rakefile_helper.rb @@ -5,10 +5,9 @@ require '../../vendor/unity/auto/generate_test_runner' require '../../vendor/unity/auto/colour_reporter' module RakefileHelpers - $return_error_on_failures = false - C_EXTENSION = '.c' + C_EXTENSION = '.c'.freeze def load_configuration(config_file) $cfg_file = config_file @@ -20,7 +19,7 @@ module RakefileHelpers CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? end - def configure_toolchain(config_file=DEFAULT_CONFIG_FILE) + def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) config_file += '.yml' unless config_file =~ /\.yml$/ load_configuration(config_file) configure_clean @@ -34,8 +33,8 @@ module RakefileHelpers def get_local_include_dirs include_dirs = $cfg['compiler']['includes']['items'].dup - include_dirs.delete_if {|dir| dir.is_a?(Array)} - return include_dirs + include_dirs.delete_if { |dir| dir.is_a?(Array) } + include_dirs end def extract_headers(filename) @@ -43,118 +42,120 @@ module RakefileHelpers lines = File.readlines(filename) lines.each do |line| m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/) - if not m.nil? + unless m.nil? includes << m[1] end end - return includes + includes end def find_source_file(header, paths) paths.each do |dir| src_file = dir + header.ext(C_EXTENSION) - if (File.exists?(src_file)) + if File.exist?(src_file) return src_file end end - return nil + nil end def tackit(strings) - case(strings) - when Array - "\"#{strings.join}\"" - when /^-/ - strings - when /\s/ - "\"#{strings}\"" - else - strings + case strings + when Array + "\"#{strings.join}\"" + when /^-/ + strings + when /\s/ + "\"#{strings}\"" + else + strings end end def squash(prefix, items) result = '' items.each { |item| result += " #{prefix}#{tackit(item)}" } - return result + result end def build_compiler_fields - command = tackit($cfg['compiler']['path']) - if $cfg['compiler']['defines']['items'].nil? - defines = '' - else - defines = squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items']) - end - options = squash('', $cfg['compiler']['options']) + command = tackit($cfg['compiler']['path']) + defines = if $cfg['compiler']['defines']['items'].nil? + '' + else + squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items']) + end + options = squash('', $cfg['compiler']['options']) includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) - return {:command => command, :defines => defines, :options => options, :includes => includes} + { :command => command, :defines => defines, :options => options, :includes => includes } end - def compile(file, defines=[]) + def compile(file, _defines = []) compiler = build_compiler_fields - cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " + + cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \ "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" execute(cmd_str + obj_file) - return obj_file + obj_file end def build_linker_fields - command = tackit($cfg['linker']['path']) - if $cfg['linker']['options'].nil? - options = '' - else - options = squash('', $cfg['linker']['options']) - end - if ($cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?) - includes = '' - else - includes = squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) - end + command = tackit($cfg['linker']['path']) + options = if $cfg['linker']['options'].nil? + '' + else + squash('', $cfg['linker']['options']) + end + includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? + '' + else + squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) + end includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) - return {:command => command, :options => options, :includes => includes} + { :command => command, :options => options, :includes => includes } end def link_it(exe_name, obj_list) linker = build_linker_fields cmd_str = "#{linker[:command]}#{linker[:includes]} " + - (obj_list.map{|obj|"#{$cfg['linker']['object_files']['path']}#{obj} "}).join + - $cfg['linker']['bin_files']['prefix'] + ' ' + - $cfg['linker']['bin_files']['destination'] + - exe_name + $cfg['linker']['bin_files']['extension'] + " #{linker[:options]}" + (obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + + $cfg['linker']['bin_files']['prefix'] + ' ' + + $cfg['linker']['bin_files']['destination'] + + exe_name + $cfg['linker']['bin_files']['extension'] + " #{linker[:options]}" execute(cmd_str) end def build_simulator_fields return nil if $cfg['simulator'].nil? - if $cfg['simulator']['path'].nil? - command = '' - else - command = (tackit($cfg['simulator']['path']) + ' ') - end - if $cfg['simulator']['pre_support'].nil? - pre_support = '' - else - pre_support = squash('', $cfg['simulator']['pre_support']) - end - if $cfg['simulator']['post_support'].nil? - post_support = '' - else - post_support = squash('', $cfg['simulator']['post_support']) - end - return {:command => command, :pre_support => pre_support, :post_support => post_support} + + command = if $cfg['simulator']['path'].nil? + '' + else + (tackit($cfg['simulator']['path']) + ' ') + end + pre_support = if $cfg['simulator']['pre_support'].nil? + '' + else + squash('', $cfg['simulator']['pre_support']) + end + post_support = if $cfg['simulator']['post_support'].nil? + '' + else + squash('', $cfg['simulator']['post_support']) + end + { :command => command, :pre_support => pre_support, :post_support => post_support } end - def execute(command_string, verbose=true, ok_to_fail=false) + def execute(command_string, verbose = true, ok_to_fail = false) report command_string output = `#{command_string}`.chomp - report(output) if (verbose && !output.nil? && (output.length > 0)) + report(output) if verbose && !output.nil? && !output.empty? unless (!$?.nil? && $?.exitstatus.zero?) || ok_to_fail raise "Command failed. (Returned #{$?.exitstatus})" end - return output + + output end def report_summary @@ -165,11 +166,10 @@ module RakefileHelpers results = Dir[results_glob] summary.targets = results report summary.run - raise "There were failures" if (summary.failures > 0) && $return_error_on_failures + raise 'There were failures' if (summary.failures > 0) && $return_error_on_failures end def run_tests(test_files) - report 'Running system tests...' # Tack on TEST define for compiling unit tests @@ -185,23 +185,21 @@ module RakefileHelpers obj_list = [] # Detect dependencies and build required required modules - header_list = (extract_headers(test) + ['cmock.h'] + [ $cfg[:cmock][:unity_helper_path] ]).compact.uniq + header_list = (extract_headers(test) + ['cmock.h'] + [$cfg[:cmock][:unity_helper_path]]).compact.uniq header_list.each do |header| + # create mocks if needed + next unless header =~ /Mock/ - #create mocks if needed - if (header =~ /Mock/) - require "../../lib/cmock.rb" - @cmock ||= CMock.new($cfg_file) - @cmock.setup_mocks([$cfg['compiler']['source_path']+header.gsub('Mock','')]) - end - + require '../../lib/cmock.rb' + @cmock ||= CMock.new($cfg_file) + @cmock.setup_mocks([$cfg['compiler']['source_path'] + header.gsub('Mock', '')]) end - #compile all mocks + # compile all mocks header_list.each do |header| - #compile source file header if it exists + # compile source file header if it exists src_file = find_source_file(header, include_dirs) - if !src_file.nil? + unless src_file.nil? obj_list << compile(src_file, test_defines) end end @@ -228,25 +226,24 @@ module RakefileHelpers # Execute unit test and generate results file simulator = build_simulator_fields executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] - if simulator.nil? - cmd_str = executable - else - cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" - end + cmd_str = if simulator.nil? + executable + else + "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" + end output = execute(cmd_str, true, true) test_results = $cfg['compiler']['build_path'] + test_base - if output.match(/OK$/m).nil? - test_results += '.testfail' - else - test_results += '.testpass' - end + test_results += if output.match(/OK$/m).nil? + '.testfail' + else + '.testpass' + end File.open(test_results, 'w') { |f| f.print output } end end def build_application(main) - - report "Building application..." + report 'Building application...' obj_list = [] load_configuration($cfg_file) @@ -256,7 +253,7 @@ module RakefileHelpers include_dirs = get_local_include_dirs extract_headers(main_path).each do |header| src_file = find_source_file(header, include_dirs) - if !src_file.nil? + unless src_file.nil? obj_list << compile(src_file) end end @@ -268,5 +265,4 @@ module RakefileHelpers # Create the executable link_it(main_base, obj_list) end - end diff --git a/lib/cmock.rb b/lib/cmock.rb index abafcdb..b4dbab5 100644 --- a/lib/cmock.rb +++ b/lib/cmock.rb @@ -4,22 +4,21 @@ # [Released under MIT License. Please refer to license.txt for details] # ========================================== -[ "../config/production_environment", - "cmock_header_parser", - "cmock_generator", - "cmock_file_writer", - "cmock_config", - "cmock_plugin_manager", - "cmock_generator_utils", - "cmock_unityhelper_parser"].each {|req| require "#{File.expand_path(File.dirname(__FILE__))}/#{req}"} +['../config/production_environment', + 'cmock_header_parser', + 'cmock_generator', + 'cmock_file_writer', + 'cmock_config', + 'cmock_plugin_manager', + 'cmock_generator_utils', + 'cmock_unityhelper_parser'].each { |req| require "#{__dir__}/#{req}" } class CMock - - def initialize(options=nil) + def initialize(options = nil) cm_config = CMockConfig.new(options) cm_unityhelper = CMockUnityHelperParser.new(cm_config) cm_writer = CMockFileWriter.new(cm_config) - cm_gen_utils = CMockGeneratorUtils.new(cm_config, {:unity_helper => cm_unityhelper}) + cm_gen_utils = CMockGeneratorUtils.new(cm_config, :unity_helper => cm_unityhelper) cm_gen_plugins = CMockPluginManager.new(cm_config, cm_gen_utils) @cm_parser = CMockHeaderParser.new(cm_config) @cm_generator = CMockGenerator.new(cm_config, cm_writer, cm_gen_utils, cm_gen_plugins) @@ -55,11 +54,11 @@ class CMock end def option_maker(options, key, val) - options = options || {} + options ||= {} options[key.to_sym] = - if val.chr == ":" + if val.chr == ':' val[1..-1].to_sym - elsif val.include? ";" + elsif val.include? ';' val.split(';') elsif val == 'true' true @@ -73,12 +72,12 @@ def option_maker(options, key, val) options end - # Command Line Support ############################### +# Command Line Support ############################### -if ($0 == __FILE__) +if $0 == __FILE__ usage = "usage: ruby #{__FILE__} (-oOptionsFile) File(s)ToMock" - if (!ARGV[0]) + unless ARGV[0] puts usage exit 1 end @@ -86,18 +85,18 @@ if ($0 == __FILE__) options = {} filelist = [] ARGV.each do |arg| - if (arg =~ /^-o\"?([a-zA-Z0-9._\\\/:\s]+)\"?/) - options.merge! CMockConfig.load_config_file_from_yaml( arg.gsub(/^-o/,'') ) - elsif (arg == "--skeleton") + if arg =~ /^-o\"?([a-zA-Z0-9._\\\/:\s]+)\"?/ + options.merge! CMockConfig.load_config_file_from_yaml(arg.gsub(/^-o/, '')) + elsif arg == '--skeleton' options[:skeleton] = true - elsif (arg =~ /^--([a-zA-Z0-9._\\\/:\s]+)=\"?([a-zA-Z0-9._\-\\\/:\s\;]+)\"?/) - options = option_maker(options, $1, $2) + elsif arg =~ /^--([a-zA-Z0-9._\\\/:\s]+)=\"?([a-zA-Z0-9._\-\\\/:\s\;]+)\"?/ + options = option_maker(options, Regexp.last_match(1), Regexp.last_match(2)) else filelist << arg end end - if (options[:skeleton]) + if options[:skeleton] CMock.new(options).setup_skeletons(filelist) else CMock.new(options).setup_mocks(filelist) diff --git a/lib/cmock_config.rb b/lib/cmock_config.rb index bcb5a38..02892ad 100644 --- a/lib/cmock_config.rb +++ b/lib/cmock_config.rb @@ -5,73 +5,72 @@ # ========================================== class CMockConfig - CMockDefaultOptions = - { - :framework => :unity, - :mock_path => 'mocks', - :mock_prefix => 'Mock', - :mock_suffix => '', - :skeleton_path => '', - :weak => '', - :subdir => nil, - :plugins => [], - :strippables => ['(?:__attribute__\s*\(+.*?\)+)'], - :attributes => ['__ramfunc', '__irq', '__fiq', 'register', 'extern'], - :c_calling_conventions => ['__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, + { + :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, - # 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*', '(\bstatic\b|\binline\b)\s*'], # Last part (\s*) is just to remove whitespaces (only to prettify the output) - } + # 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*', '(\bstatic\b|\binline\b)\s*'] # Last part (\s*) is just to remove whitespaces (only to prettify the output) + } - 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" + 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) + # do some quick type verification + %i[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) + puts "WARNING: :#{opt} 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)) + %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].class == Array) options[opt] = [] - puts "WARNING: :#{opt.to_s} should be an array." unless (options[:verbosity] < 1) + puts "WARNING: :#{opt} should be an array." unless options[:verbosity] < 1 end end options[:unity_helper_path] ||= options[:unity_helper] @@ -87,25 +86,25 @@ class CMockConfig end options[:plugins].compact! - options[:plugins].map! {|p| p.to_sym} + options[:plugins].map!(&:to_sym) @options = options - treat_as_map = standard_treat_as_map()#.clone + 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.to_s}() return @options[:#{key.to_s}] end") + eval("def #{key}() return @options[:#{key}] end") end end end - def load_config_file_from_yaml yaml_filename + 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 + def self.load_config_file_from_yaml(yaml_filename) require 'yaml' require 'fileutils' YAML.load_file(yaml_filename)[:cmock] @@ -116,9 +115,9 @@ class CMockConfig end def load_unity_helper - return nil unless (@options[:unity_helper_path]) + return nil unless @options[:unity_helper_path] - return @options[:unity_helper_path].inject("") do |unity_helper, filename| + @options[:unity_helper_path].inject('') do |unity_helper, filename| unity_helper + "\n" + File.new(filename).read end end diff --git a/lib/cmock_file_writer.rb b/lib/cmock_file_writer.rb index c9dae81..6c31848 100644 --- a/lib/cmock_file_writer.rb +++ b/lib/cmock_file_writer.rb @@ -5,7 +5,6 @@ # ========================================== class CMockFileWriter - attr_reader :config def initialize(config) @@ -13,20 +12,21 @@ class CMockFileWriter end def create_subdir(subdir) - if !Dir.exists?("#{@config.mock_path}/") + unless Dir.exist?("#{@config.mock_path}/") require 'fileutils' FileUtils.mkdir_p "#{@config.mock_path}/" end - if subdir && !Dir.exists?("#{@config.mock_path}/#{subdir+'/' if subdir}") + if subdir && !Dir.exist?("#{@config.mock_path}/#{subdir + '/' if subdir}") require 'fileutils' - FileUtils.mkdir_p "#{@config.mock_path}/#{subdir+'/' if subdir}" + FileUtils.mkdir_p "#{@config.mock_path}/#{subdir + '/' if subdir}" end 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}" + + 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 @@ -35,7 +35,8 @@ class CMockFileWriter 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}" + + full_file_name = "#{@config.skeleton_path}/#{subdir + '/' if subdir}#{filename}" File.open(full_file_name, 'a') do |file| yield(file, filename) end @@ -45,7 +46,7 @@ class CMockFileWriter def update_file(dest, src) require 'fileutils' - FileUtils.rm(dest) if (File.exist?(dest)) + FileUtils.rm(dest) if File.exist?(dest) FileUtils.cp(src, dest) FileUtils.rm(src) end diff --git a/lib/cmock_generator.rb b/lib/cmock_generator.rb index 959164d..09622ff 100644 --- a/lib/cmock_generator.rb +++ b/lib/cmock_generator.rb @@ -5,7 +5,6 @@ # ========================================== 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) @@ -16,34 +15,33 @@ class CMockGenerator @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 + @include_inline = @config.treat_inlines + @ordered = @config.enforce_strict_ordering + @framework = @config.framework.to_s @fail_on_unexpected_calls = @config.fail_on_unexpected_calls - @subdir = @config.subdir + @subdir = @config.subdir - @includes_h_pre_orig_header = (@config.includes || @config.includes_h_pre_orig_header || []).map{|h| h =~ /\n" file << "#include \n" file << "#include \n" file << "#include \"cmock.h\"\n" - @includes_c_pre_header.each {|inc| file << "#include #{inc}\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"} + @includes_c_post_header.each { |inc| file << "#include #{inc}\n" } file << "\n" strs = [] functions.each do |func| strs << func[:name] - func[:args].each {|arg| strs << arg[:name] } + func[:args].each { |arg| strs << arg[:name] } end strs.uniq.sort.each do |str| file << "static const char* CMockString_#{str} = \"#{str}\";\n" @@ -191,7 +189,7 @@ class CMockGenerator file << "\n} CMOCK_#{function[:name]}_CALL_INSTANCE;\n\n" end file << "static struct #{@clean_mock_name}Instance\n{\n" - if (functions.size == 0) + if functions.empty? file << " unsigned char placeHolder;\n" end functions.each do |function| @@ -203,7 +201,7 @@ class CMockGenerator def create_extern_declarations(file) file << "extern jmp_buf AbortFrame;\n" - if (@ordered) + if @ordered file << "extern int GlobalExpectCount;\n" file << "extern int GlobalVerifyOrder;\n" end @@ -234,13 +232,13 @@ class CMockGenerator 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 + file << functions.collect { |function| @plugins.run(:mock_destroy, function) }.join - unless (@fail_on_unexpected_calls) - file << functions.collect {|function| @plugins.run(:mock_ignore, function)}.join + unless @fail_on_unexpected_calls + file << functions.collect { |function| @plugins.run(:mock_ignore, function) }.join end - if (@ordered) + if @ordered file << " GlobalExpectCount = 0;\n" file << " GlobalVerifyOrder = 0;\n" end @@ -253,15 +251,15 @@ class CMockGenerator (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?) + args_string += (', ' + function[:var_arg]) unless function[:var_arg].nil? # Create mock function - if (not @weak.empty?) - file << "#if defined (__IAR_SYSTEMS_ICC__)\n" - file << "#pragma weak #{function[:name]}\n" - file << "#else\n" - file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string}) #{weak};\n" - file << "#endif\n\n" + unless @weak.empty? + file << "#if defined (__IAR_SYSTEMS_ICC__)\n" + file << "#pragma weak #{function[:name]}\n" + file << "#else\n" + file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string}) #{weak};\n" + file << "#endif\n\n" end file << "#{function_mod_and_rettype} #{function[:name]}(#{args_string})\n" file << "{\n" @@ -273,7 +271,7 @@ class CMockGenerator 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) + 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" @@ -281,7 +279,7 @@ class CMockGenerator end file << @plugins.run(:mock_implementation, function) file << " UNITY_CLR_DETAILS();\n" - file << " return cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?]) + file << " return cmock_call_instance->ReturnVal;\n" unless function[:return][:void?] file << "}\n\n" end @@ -296,16 +294,16 @@ class CMockGenerator (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?) + args_string += (', ' + function[:var_arg]) unless function[:var_arg].nil? decl = "#{function_mod_and_rettype} #{function[:name]}(#{args_string})" - unless (existing.include?(decl)) + unless 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?]) + 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 diff --git a/lib/cmock_generator_plugin_array.rb b/lib/cmock_generator_plugin_array.rb index 3b73708..a9864ab 100644 --- a/lib/cmock_generator_plugin_array.rb +++ b/lib/cmock_generator_plugin_array.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginArray - attr_reader :priority attr_accessor :config, :utils, :unity_helper, :ordered def initialize(config, utils) @@ -18,46 +17,47 @@ class CMockGeneratorPluginArray end def instance_typedefs(function) - function[:args].inject("") do |all, arg| - (arg[:ptr?]) ? all + " int Expected_#{arg[:name]}_Depth;\n" : all + 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_call = 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?]) - return "#define #{function[:name]}_ExpectWithArray(#{args_call}) #{function[:name]}_CMockExpectWithArray(__LINE__, #{args_call})\n" + + 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" + + 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 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(', ') - 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 + 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 << " cmock_call_instance->ReturnVal = cmock_to_return;\n" unless function[:return][:void?] lines << "}\n\n" end - end diff --git a/lib/cmock_generator_plugin_callback.rb b/lib/cmock_generator_plugin_callback.rb index 297e357..205d4d6 100644 --- a/lib/cmock_generator_plugin_callback.rb +++ b/lib/cmock_generator_plugin_callback.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginCallback - attr_accessor :include_count attr_reader :priority attr_reader :config, :utils @@ -30,7 +29,7 @@ class CMockGeneratorPluginCallback return_type = function[:return][:type] action = @config.callback_after_arg_check ? 'AddCallback' : 'Stub' 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" ] + 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]});\n" \ "void #{func_name}_AddCallback(CMOCK_#{func_name}_CALLBACK Callback);\n" \ "void #{func_name}_Stub(CMOCK_#{func_name}_CALLBACK Callback);\n" \ @@ -69,7 +68,7 @@ class CMockGeneratorPluginCallback def mock_interfaces(function) func_name = function[:name] has_ignore = @config.plugins.include? :ignore - lines = "" + lines = '' lines << "void #{func_name}_AddCallback(CMOCK_#{func_name}_CALLBACK Callback)\n{\n" lines << " Mock.#{func_name}_IgnoreBool = (int)0;\n" if has_ignore lines << " Mock.#{func_name}_CallbackBool = (int)1;\n" diff --git a/lib/cmock_generator_plugin_cexception.rb b/lib/cmock_generator_plugin_cexception.rb index 39d36d6..a757669 100644 --- a/lib/cmock_generator_plugin_cexception.rb +++ b/lib/cmock_generator_plugin_cexception.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginCexception - attr_reader :priority attr_reader :config, :utils @@ -16,36 +15,35 @@ class CMockGeneratorPluginCexception end def include_files - return "#include \"CException.h\"\n" + "#include \"CException.h\"\n" end - def instance_typedefs(function) + def instance_typedefs(_function) " CEXCEPTION_T ExceptionToThrow;\n" end def mock_function_declarations(function) - if (function[:args_string] == "void") - return "#define #{function[:name]}_ExpectAndThrow(cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, cmock_to_throw)\n" + + if function[:args_string] == 'void' + "#define #{function[:name]}_ExpectAndThrow(cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, cmock_to_throw)\n" \ "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, CEXCEPTION_T cmock_to_throw);\n" else - return "#define #{function[:name]}_ExpectAndThrow(#{function[:args_call]}, cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, #{function[:args_call]}, cmock_to_throw)\n" + + "#define #{function[:name]}_ExpectAndThrow(#{function[:args_call]}, cmock_to_throw) #{function[:name]}_CMockExpectAndThrow(__LINE__, #{function[:args_call]}, cmock_to_throw)\n" \ "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, CEXCEPTION_T cmock_to_throw);\n" end end - def mock_implementation(function) - " if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)\n {\n" + - " UNITY_CLR_DETAILS();\n" + - " Throw(cmock_call_instance->ExceptionToThrow);\n }\n" + def mock_implementation(_function) + " if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)\n {\n" \ + " UNITY_CLR_DETAILS();\n" \ + " Throw(cmock_call_instance->ExceptionToThrow);\n }\n" end def mock_interfaces(function) - arg_insert = (function[:args_string] == "void") ? "" : "#{function[:args_string]}, " - [ "void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{arg_insert}CEXCEPTION_T cmock_to_throw)\n{\n", - @utils.code_add_base_expectation(function[:name]), - @utils.code_call_argument_loader(function), - " cmock_call_instance->ExceptionToThrow = cmock_to_throw;\n", - "}\n\n" ].join + arg_insert = function[:args_string] == 'void' ? '' : "#{function[:args_string]}, " + ["void #{function[:name]}_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, #{arg_insert}CEXCEPTION_T cmock_to_throw)\n{\n", + @utils.code_add_base_expectation(function[:name]), + @utils.code_call_argument_loader(function), + " cmock_call_instance->ExceptionToThrow = cmock_to_throw;\n", + "}\n\n"].join end - end diff --git a/lib/cmock_generator_plugin_expect.rb b/lib/cmock_generator_plugin_expect.rb index 44bb98b..9832631 100644 --- a/lib/cmock_generator_plugin_expect.rb +++ b/lib/cmock_generator_plugin_expect.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginExpect - attr_reader :priority attr_accessor :config, :utils, :unity_helper, :ordered @@ -17,7 +16,7 @@ class CMockGeneratorPluginExpect @unity_helper = @utils.helpers[:unity_helper] @priority = 5 - if (@config.plugins.include? :expect_any_args) + if @config.plugins.include? :expect_any_args alias :mock_implementation :mock_implementation_might_check_args else alias :mock_implementation :mock_implementation_always_check_args @@ -25,9 +24,9 @@ class CMockGeneratorPluginExpect end def instance_typedefs(function) - lines = "" - lines << " #{function[:return][:type]} ReturnVal;\n" unless (function[:return][:void?]) - lines << " int CallOrder;\n" if (@ordered) + lines = '' + lines << " #{function[:return][:type]} ReturnVal;\n" unless function[:return][:void?] + lines << " int CallOrder;\n" if @ordered function[:args].each do |arg| lines << " #{arg[:type]} Expected_#{arg[:name]};\n" end @@ -35,27 +34,27 @@ class CMockGeneratorPluginExpect end def mock_function_declarations(function) - if (function[:args].empty?) - if (function[:return][:void?]) - return "#define #{function[:name]}_Expect() #{function[:name]}_CMockExpect(__LINE__)\n" + + if function[:args].empty? + if function[:return][:void?] + "#define #{function[:name]}_Expect() #{function[:name]}_CMockExpect(__LINE__)\n" \ "void #{function[:name]}_CMockExpect(UNITY_LINE_TYPE cmock_line);\n" else - return "#define #{function[:name]}_ExpectAndReturn(cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, cmock_retval)\n" + + "#define #{function[:name]}_ExpectAndReturn(cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, cmock_retval)\n" \ "void #{function[:name]}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n" end else - if (function[:return][:void?]) - return "#define #{function[:name]}_Expect(#{function[:args_call]}) #{function[:name]}_CMockExpect(__LINE__, #{function[:args_call]})\n" + + if function[:return][:void?] + "#define #{function[:name]}_Expect(#{function[:args_call]}) #{function[:name]}_CMockExpect(__LINE__, #{function[:args_call]})\n" \ "void #{function[:name]}_CMockExpect(UNITY_LINE_TYPE cmock_line, #{function[:args_string]});\n" else - return "#define #{function[:name]}_ExpectAndReturn(#{function[:args_call]}, cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, #{function[:args_call]}, cmock_retval)\n" + + "#define #{function[:name]}_ExpectAndReturn(#{function[:args_call]}, cmock_retval) #{function[:name]}_CMockExpectAndReturn(__LINE__, #{function[:args_call]}, cmock_retval)\n" \ "void #{function[:name]}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, #{function[:return][:str]});\n" end end end def mock_implementation_always_check_args(function) - lines = "" + lines = '' function[:args].each do |arg| lines << @utils.code_verify_an_arg_expectation(function, arg) end @@ -63,7 +62,8 @@ class CMockGeneratorPluginExpect end def mock_implementation_might_check_args(function) - return "" if (function[:args].empty?) + return '' if function[:args].empty? + lines = " if (!cmock_call_instance->ExpectAnyArgsBool)\n {\n" function[:args].each do |arg| lines << @utils.code_verify_an_arg_expectation(function, arg) @@ -73,24 +73,24 @@ class CMockGeneratorPluginExpect end def mock_interfaces(function) - lines = "" + lines = '' func_name = function[:name] - if (function[:return][:void?]) - if (function[:args_string] == "void") - lines << "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line)\n{\n" - else - lines << "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line, #{function[:args_string]})\n{\n" - end - else - if (function[:args_string] == "void") - lines << "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" - else - lines << "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, #{function[:return][:str]})\n{\n" - end - end + lines << if function[:return][:void?] + if function[:args_string] == 'void' + "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line)\n{\n" + else + "void #{func_name}_CMockExpect(UNITY_LINE_TYPE cmock_line, #{function[:args_string]})\n{\n" + end + else + if function[:args_string] == 'void' + "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" + else + "void #{func_name}_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:args_string]}, #{function[:return][:str]})\n{\n" + end + end lines << @utils.code_add_base_expectation(func_name) lines << @utils.code_call_argument_loader(function) - lines << @utils.code_assign_argument_quickly("cmock_call_instance->ReturnVal", function[:return]) unless (function[:return][:void?]) + lines << @utils.code_assign_argument_quickly('cmock_call_instance->ReturnVal', function[:return]) unless function[:return][:void?] lines << "}\n\n" end diff --git a/lib/cmock_generator_plugin_expect_any_args.rb b/lib/cmock_generator_plugin_expect_any_args.rb index 0c1c74e..1261792 100644 --- a/lib/cmock_generator_plugin_expect_any_args.rb +++ b/lib/cmock_generator_plugin_expect_any_args.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginExpectAnyArgs - attr_reader :priority attr_reader :config, :utils @@ -15,39 +14,39 @@ class CMockGeneratorPluginExpectAnyArgs @priority = 3 end - def instance_typedefs(function) + def instance_typedefs(_function) " int ExpectAnyArgsBool;\n" end def mock_function_declarations(function) - unless (function[:args].empty?) - if (function[:return][:void?]) - return "#define #{function[:name]}_ExpectAnyArgs() #{function[:name]}_CMockExpectAnyArgs(__LINE__)\n" + + if function[:args].empty? + '' + else + if function[:return][:void?] + "#define #{function[:name]}_ExpectAnyArgs() #{function[:name]}_CMockExpectAnyArgs(__LINE__)\n" \ "void #{function[:name]}_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line);\n" else - return "#define #{function[:name]}_ExpectAnyArgsAndReturn(cmock_retval) #{function[:name]}_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval)\n" + + "#define #{function[:name]}_ExpectAnyArgsAndReturn(cmock_retval) #{function[:name]}_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval)\n" \ "void #{function[:name]}_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n" end - else - "" end end def mock_interfaces(function) - lines = "" - unless (function[:args].empty?) - if (function[:return][:void?]) - lines << "void #{function[:name]}_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line)\n{\n" - else - lines << "void #{function[:name]}_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" - end + lines = '' + unless function[:args].empty? + lines << if function[:return][:void?] + "void #{function[:name]}_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line)\n{\n" + else + "void #{function[:name]}_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" + end lines << @utils.code_add_base_expectation(function[:name], true) - unless (function[:return][:void?]) + unless function[:return][:void?] lines << " cmock_call_instance->ReturnVal = cmock_to_return;\n" end lines << " cmock_call_instance->ExpectAnyArgsBool = (int)1;\n" lines << "}\n\n" end - return lines + lines end end diff --git a/lib/cmock_generator_plugin_ignore.rb b/lib/cmock_generator_plugin_ignore.rb index 8f31967..a7a9976 100644 --- a/lib/cmock_generator_plugin_ignore.rb +++ b/lib/cmock_generator_plugin_ignore.rb @@ -5,7 +5,6 @@ # ========================================== class CMockGeneratorPluginIgnore - attr_reader :priority attr_reader :config, :utils @@ -16,7 +15,7 @@ class CMockGeneratorPluginIgnore end def instance_structure(function) - if (function[:return][:void?]) + if function[:return][:void?] " int #{function[:name]}_IgnoreBool;\n" else " int #{function[:name]}_IgnoreBool;\n #{function[:return][:type]} #{function[:name]}_FinalReturn;\n" @@ -24,11 +23,11 @@ class CMockGeneratorPluginIgnore end def mock_function_declarations(function) - if (function[:return][:void?]) - return "#define #{function[:name]}_Ignore() #{function[:name]}_CMockIgnore()\n" + + if function[:return][:void?] + "#define #{function[:name]}_Ignore() #{function[:name]}_CMockIgnore()\n" \ "void #{function[:name]}_CMockIgnore(void);\n" else - return "#define #{function[:name]}_IgnoreAndReturn(cmock_retval) #{function[:name]}_CMockIgnoreAndReturn(__LINE__, cmock_retval)\n" + + "#define #{function[:name]}_IgnoreAndReturn(cmock_retval) #{function[:name]}_CMockIgnoreAndReturn(__LINE__, cmock_retval)\n" \ "void #{function[:name]}_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n" end end @@ -36,28 +35,28 @@ class CMockGeneratorPluginIgnore def mock_implementation_precheck(function) lines = " if (Mock.#{function[:name]}_IgnoreBool)\n {\n" lines << " UNITY_CLR_DETAILS();\n" - if (function[:return][:void?]) + if function[:return][:void?] lines << " return;\n }\n" else - retval = function[:return].merge( { :name => "cmock_call_instance->ReturnVal"} ) + retval = function[:return].merge(:name => 'cmock_call_instance->ReturnVal') lines << " if (cmock_call_instance == NULL)\n return Mock.#{function[:name]}_FinalReturn;\n" - lines << " " + @utils.code_assign_argument_quickly("Mock.#{function[:name]}_FinalReturn", retval) unless (retval[:void?]) + lines << ' ' + @utils.code_assign_argument_quickly("Mock.#{function[:name]}_FinalReturn", retval) unless retval[:void?] lines << " return cmock_call_instance->ReturnVal;\n }\n" end lines end def mock_interfaces(function) - lines = "" - if (function[:return][:void?]) - lines << "void #{function[:name]}_CMockIgnore(void)\n{\n" - else - lines << "void #{function[:name]}_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" - end - if (!function[:return][:void?]) + lines = '' + lines << if function[:return][:void?] + "void #{function[:name]}_CMockIgnore(void)\n{\n" + else + "void #{function[:name]}_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]})\n{\n" + end + unless function[:return][:void?] lines << @utils.code_add_base_expectation(function[:name], false) end - unless (function[:return][:void?]) + unless function[:return][:void?] lines << " cmock_call_instance->ReturnVal = cmock_to_return;\n" end lines << " Mock.#{function[:name]}_IgnoreBool = (int)1;\n" diff --git a/lib/cmock_generator_plugin_ignore_arg.rb b/lib/cmock_generator_plugin_ignore_arg.rb index ef40e50..855f7d3 100644 --- a/lib/cmock_generator_plugin_ignore_arg.rb +++ b/lib/cmock_generator_plugin_ignore_arg.rb @@ -2,13 +2,13 @@ class CMockGeneratorPluginIgnoreArg attr_reader :priority attr_accessor :utils - def initialize(config, utils) + def initialize(_config, utils) @utils = utils @priority = 10 end def instance_typedefs(function) - lines = "" + lines = '' function[:args].each do |arg| lines << " int IgnoreArg_#{arg[:name]};\n" end @@ -16,7 +16,7 @@ class CMockGeneratorPluginIgnoreArg end def mock_function_declarations(function) - lines = "" + lines = '' function[:args].each do |arg| lines << "#define #{function[:name]}_IgnoreArg_#{arg[:name]}()" lines << " #{function[:name]}_CMockIgnoreArg_#{arg[:name]}(__LINE__)\n" @@ -31,8 +31,8 @@ class CMockGeneratorPluginIgnoreArg function[:args].each do |arg| lines << "void #{func_name}_CMockIgnoreArg_#{arg[:name]}(UNITY_LINE_TYPE cmock_line)\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" + 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" lines << " UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);\n" lines << " cmock_call_instance->IgnoreArg_#{arg[:name]} = 1;\n" lines << "}\n\n" diff --git a/lib/cmock_generator_plugin_return_thru_ptr.rb b/lib/cmock_generator_plugin_return_thru_ptr.rb index 1c1af06..32e1f67 100644 --- a/lib/cmock_generator_plugin_return_thru_ptr.rb +++ b/lib/cmock_generator_plugin_return_thru_ptr.rb @@ -2,41 +2,41 @@ class CMockGeneratorPluginReturnThruPtr attr_reader :priority attr_accessor :utils - def initialize(config, utils) + def initialize(_config, utils) @utils = utils @priority = 9 end def instance_typedefs(function) - lines = "" + lines = '' function[:args].each do |arg| - if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?]) - lines << " int ReturnThruPtr_#{arg[:name]}_Used;\n" - lines << " #{arg[:type]} ReturnThruPtr_#{arg[:name]}_Val;\n" - lines << " int ReturnThruPtr_#{arg[:name]}_Size;\n" - end + next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?]) + + lines << " int ReturnThruPtr_#{arg[:name]}_Used;\n" + lines << " #{arg[:type]} ReturnThruPtr_#{arg[:name]}_Val;\n" + lines << " int ReturnThruPtr_#{arg[:name]}_Size;\n" end lines end def mock_function_declarations(function) - lines = "" + lines = '' function[:args].each do |arg| - if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?]) - 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 - if (arg[:type][-1] == '*') - lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(#{arg[:type][0..-2]}))\n" - else - lines << " #{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]}, (int)(cmock_len * (int)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]}, int cmock_size);\n" - end + next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?]) + + 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] == '*' + " #{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]}, (int)(cmock_len * (int)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]}, int cmock_size);\n" end lines end @@ -46,17 +46,17 @@ class CMockGeneratorPluginReturnThruPtr func_name = function[:name] function[:args].each do |arg| arg_name = arg[:name] - if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?]) - lines << "void #{func_name}_CMockReturnMemThruPtr_#{arg_name}(UNITY_LINE_TYPE cmock_line, #{arg[:type]} #{arg_name}, int 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" - lines << " UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);\n" - lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Used = 1;\n" - lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Val = #{arg_name};\n" - lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Size = cmock_size;\n" - lines << "}\n\n" - end + 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}, int 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" + lines << " UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);\n" + lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Used = 1;\n" + lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Val = #{arg_name};\n" + lines << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Size = cmock_size;\n" + lines << "}\n\n" end lines end @@ -65,14 +65,14 @@ class CMockGeneratorPluginReturnThruPtr lines = [] function[:args].each do |arg| arg_name = arg[:name] - if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?]) - 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 << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Size);\n" - lines << " }\n" - end + next unless @utils.ptr_or_str?(arg[:type]) && !(arg[:const?]) + + 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 << " cmock_call_instance->ReturnThruPtr_#{arg_name}_Size);\n" + lines << " }\n" end lines end diff --git a/lib/cmock_generator_utils.rb b/lib/cmock_generator_utils.rb index fd0f15b..bc8025e 100644 --- a/lib/cmock_generator_utils.rb +++ b/lib/cmock_generator_utils.rb @@ -5,10 +5,9 @@ # ========================================== class CMockGeneratorUtils - attr_accessor :config, :helpers, :ordered, :ptr_handling, :arrays, :cexception - def initialize(config, helpers={}) + def initialize(config, helpers = {}) @config = config @ptr_handling = @config.when_ptr @ordered = @config.enforce_strict_ordering @@ -16,9 +15,9 @@ class CMockGeneratorUtils @cexception = @config.plugins.include? :cexception @expect_any = @config.plugins.include? :expect_any_args @return_thru_ptr = @config.plugins.include? :return_thru_ptr - @ignore_arg = @config.plugins.include? :ignore_arg - @ignore = @config.plugins.include? :ignore - @treat_as = @config.treat_as + @ignore_arg = @config.plugins.include? :ignore_arg + @ignore = @config.plugins.include? :ignore + @treat_as = @config.treat_as @helpers = helpers end @@ -36,78 +35,78 @@ class CMockGeneratorUtils end def code_verify_an_arg_expectation(function, arg) - if (@arrays) - case(@ptr_handling) - when :smart then code_verify_an_arg_expectation_with_smart_arrays(function, arg) - when :compare_data then code_verify_an_arg_expectation_with_normal_arrays(function, arg) - when :compare_ptr then raise "ERROR: the array plugin doesn't enjoy working with :compare_ptr only. Disable one option." + if @arrays + case @ptr_handling + when :smart then code_verify_an_arg_expectation_with_smart_arrays(function, arg) + when :compare_data then code_verify_an_arg_expectation_with_normal_arrays(function, arg) + when :compare_ptr then raise "ERROR: the array plugin doesn't enjoy working with :compare_ptr only. Disable one option." end else code_verify_an_arg_expectation_with_no_arrays(function, arg) end end - def code_add_base_expectation(func_name, global_ordering_supported=true) + def code_add_base_expectation(func_name, global_ordering_supported = true) lines = " CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_#{func_name}_CALL_INSTANCE));\n" lines << " CMOCK_#{func_name}_CALL_INSTANCE* cmock_call_instance = (CMOCK_#{func_name}_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" lines << " UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);\n" lines << " memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));\n" lines << " Mock.#{func_name}_CallInstance = CMock_Guts_MemChain(Mock.#{func_name}_CallInstance, cmock_guts_index);\n" - lines << " Mock.#{func_name}_IgnoreBool = (int)0;\n" if (@ignore) + lines << " Mock.#{func_name}_IgnoreBool = (int)0;\n" if @ignore lines << " cmock_call_instance->LineNumber = cmock_line;\n" - lines << " cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if (@ordered and global_ordering_supported) - lines << " cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if (@cexception) - lines << " cmock_call_instance->ExpectAnyArgsBool = (int)0;\n" if (@expect_any) + lines << " cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" if @ordered && global_ordering_supported + lines << " cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n" if @cexception + lines << " cmock_call_instance->ExpectAnyArgsBool = (int)0;\n" if @expect_any lines end - def code_add_an_arg_expectation(arg, depth=1) + def code_add_an_arg_expectation(arg, depth = 1) lines = code_assign_argument_quickly("cmock_call_instance->Expected_#{arg[:name]}", arg) - lines << " cmock_call_instance->Expected_#{arg[:name]}_Depth = #{arg[:name]}_Depth;\n" if (@arrays and (depth.class == String)) - lines << " 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 and ptr_or_str?(arg[:type]) and not arg[:const?]) + lines << " cmock_call_instance->Expected_#{arg[:name]}_Depth = #{arg[:name]}_Depth;\n" if @arrays && (depth.class == 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 end def code_assign_argument_quickly(dest, arg) - if (arg[:ptr?] or @treat_as.include?(arg[:type])) + if arg[:ptr?] || @treat_as.include?(arg[:type]) " #{dest} = #{arg[:name]};\n" else assert_expr = "sizeof(#{arg[:name]}) == sizeof(#{arg[:type]}) ? 1 : -1" comment = "/* add #{arg[:type]} to :treat_as_array if this causes an error */" - " memcpy((void*)(&#{dest}), (void*)(&#{arg[:name]}),\n" + - " sizeof(#{arg[:type]}[#{assert_expr}])); #{comment}\n" + " memcpy((void*)(&#{dest}), (void*)(&#{arg[:name]}),\n" \ + " sizeof(#{arg[:type]}[#{assert_expr}])); #{comment}\n" end end def code_add_argument_loader(function) - if (function[:args_string] != "void") - if (@arrays) + if function[:args_string] != 'void' + if @arrays args_string = function[:args].map do |m| type = arg_type_with_const(m) 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) ) } + - "}\n\n" + "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)) } + + "}\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) } + - "}\n\n" + "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) } + + "}\n\n" end else - "" + '' end end def code_call_argument_loader(function) - if (function[:args_string] != "void") + if function[:args_string] != 'void' args = function[:args].map do |m| - if (@arrays and m[:ptr?] and not m[:array_data?]) + if @arrays && m[:ptr?] && !(m[:array_data?]) "#{m[:name]}, 1" - elsif (@arrays and m[:array_size?]) + elsif @arrays && m[:array_size?] "#{m[:name]}, #{m[:name]}" else m[:name] @@ -115,60 +114,60 @@ class CMockGeneratorUtils end " CMockExpectParameters_#{function[:name]}(cmock_call_instance, #{args.join(', ')});\n" else - "" + '' end end def ptr_or_str?(arg_type) - return (arg_type.include? '*' or - @treat_as.fetch(arg_type, "").include? '*') + (arg_type.include?('*') || + @treat_as.fetch(arg_type, '').include?('*')) end - #private ###################### + # private ###################### - def lookup_expect_type(function, arg) + def lookup_expect_type(_function, arg) c_type = arg[:type] arg_name = arg[:name] expected = "cmock_call_instance->Expected_#{arg_name}" ignore = "cmock_call_instance->IgnoreArg_#{arg_name}" - unity_func = if ((arg[:ptr?]) and ((c_type =~ /\*\*/) or (@ptr_handling == :compare_ptr))) + unity_func = if (arg[:ptr?]) && ((c_type =~ /\*\*/) || (@ptr_handling == :compare_ptr)) ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] else - (@helpers.nil? or @helpers[:unity_helper].nil?) ? ["UNITY_TEST_ASSERT_EQUAL",''] : @helpers[:unity_helper].get_helper(c_type) + @helpers.nil? || @helpers[:unity_helper].nil? ? ['UNITY_TEST_ASSERT_EQUAL', ''] : @helpers[:unity_helper].get_helper(c_type) end - return c_type, arg_name, expected, ignore, unity_func[0], unity_func[1] + [c_type, arg_name, expected, ignore, unity_func[0], unity_func[1]] end def code_verify_an_arg_expectation_with_no_arrays(function, arg) c_type, arg_name, expected, ignore, unity_func, pre = lookup_expect_type(function, arg) - lines = "" + lines = '' lines << " if (!#{ignore})\n" if @ignore_arg lines << " {\n" lines << " UNITY_SET_DETAILS(CMockString_#{function[:name]},CMockString_#{arg_name});\n" - case(unity_func) - when "UNITY_TEST_ASSERT_EQUAL_MEMORY" - c_type_local = c_type.gsub(/\*$/,'') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" - when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY" - if (pre == '&') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << " else\n" - lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, CMockStringMismatch); }\n" - end - when /_ARRAY/ - if (pre == '&') - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << " else\n" - lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, CMockStringMismatch); }\n" - end + case unity_func + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY' + c_type_local = c_type.gsub(/\*$/, '') + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' + if pre == '&' + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), cmock_line, CMockStringMismatch);\n" else - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << " else\n" + lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), cmock_line, CMockStringMismatch); }\n" + end + when /_ARRAY/ + if pre == '&' + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, CMockStringMismatch);\n" + else + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << " else\n" + lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, 1, cmock_line, CMockStringMismatch); }\n" + end + else + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" end lines << " }\n" lines @@ -176,35 +175,35 @@ class CMockGeneratorUtils def code_verify_an_arg_expectation_with_normal_arrays(function, arg) c_type, arg_name, expected, ignore, unity_func, pre = lookup_expect_type(function, arg) - depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1 - lines = "" + depth_name = arg[:ptr?] ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1 + lines = '' lines << " if (!#{ignore})\n" if @ignore_arg lines << " {\n" lines << " UNITY_SET_DETAILS(CMockString_#{function[:name]},CMockString_#{arg_name});\n" - case(unity_func) - when "UNITY_TEST_ASSERT_EQUAL_MEMORY" - c_type_local = c_type.gsub(/\*$/,'') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" - when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY" - if (pre == '&') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << " else\n" - lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, CMockStringMismatch); }\n" - end - when /_ARRAY/ - if (pre == '&') - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << " else\n" - lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch); }\n" - end + case unity_func + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY' + c_type_local = c_type.gsub(/\*$/, '') + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' + if pre == '&' + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), cmock_line, CMockStringMismatch);\n" else - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << " else\n" + lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), #{depth_name}, cmock_line, CMockStringMismatch); }\n" + end + when /_ARRAY/ + if pre == '&' + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch);\n" + else + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << " else\n" + lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch); }\n" + end + else + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" end lines << " }\n" lines @@ -212,40 +211,39 @@ class CMockGeneratorUtils def code_verify_an_arg_expectation_with_smart_arrays(function, arg) c_type, arg_name, expected, ignore, unity_func, pre = lookup_expect_type(function, arg) - depth_name = (arg[:ptr?]) ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1 - lines = "" + depth_name = arg[:ptr?] ? "cmock_call_instance->Expected_#{arg_name}_Depth" : 1 + lines = '' lines << " if (!#{ignore})\n" if @ignore_arg lines << " {\n" lines << " UNITY_SET_DETAILS(CMockString_#{function[:name]},CMockString_#{arg_name});\n" - case(unity_func) - when "UNITY_TEST_ASSERT_EQUAL_MEMORY" - c_type_local = c_type.gsub(/\*$/,'') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" - when "UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY" - if (pre == '&') - lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << ((depth_name != 1) ? " else if (#{depth_name} == 0)\n { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch); }\n" : "") - lines << " else\n" - lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*','')}), #{depth_name}, cmock_line, CMockStringMismatch); }\n" - end - when /_ARRAY/ - if (pre == '&') - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch);\n" - else - lines << " if (#{pre}#{expected} == NULL)\n" - lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" - lines << ((depth_name != 1) ? " else if (#{depth_name} == 0)\n { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch); }\n" : "") - lines << " else\n" - lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch); }\n" - end + case unity_func + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY' + c_type_local = c_type.gsub(/\*$/, '') + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type_local}), cmock_line, CMockStringMismatch);\n" + when 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' + if pre == '&' + lines << " UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), #{depth_name}, cmock_line, CMockStringMismatch);\n" else - lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << (depth_name != 1 ? " else if (#{depth_name} == 0)\n { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch); }\n" : '') + lines << " else\n" + lines << " { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(#{pre}#{expected}), (void*)(#{pre}#{arg_name}), sizeof(#{c_type.sub('*', '')}), #{depth_name}, cmock_line, CMockStringMismatch); }\n" + end + when /_ARRAY/ + if pre == '&' + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch);\n" + else + lines << " if (#{pre}#{expected} == NULL)\n" + lines << " { UNITY_TEST_ASSERT_NULL(#{pre}#{arg_name}, cmock_line, CMockStringExpNULL); }\n" + lines << (depth_name != 1 ? " else if (#{depth_name} == 0)\n { UNITY_TEST_ASSERT_EQUAL_PTR(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch); }\n" : '') + lines << " else\n" + lines << " { #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, #{depth_name}, cmock_line, CMockStringMismatch); }\n" + end + else + lines << " #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n" end lines << " }\n" lines end - end diff --git a/lib/cmock_header_parser.rb b/lib/cmock_header_parser.rb index 1768eda..9e72501 100644 --- a/lib/cmock_header_parser.rb +++ b/lib/cmock_header_parser.rb @@ -5,7 +5,6 @@ # ========================================== class CMockHeaderParser - attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs, :treat_inlines, :inline_function_patterns def initialize(cfg) @@ -18,35 +17,35 @@ class CMockHeaderParser @treat_as_void = (['void'] + cfg.treat_as_void).uniq @function_declaration_parse_base_match = '([\w\s\*\(\),\[\]]+??)\(([\w\s\*\(\),\.\[\]+\-\/]*)\)' @declaration_parse_matcher = /#{@function_declaration_parse_base_match}$/m - @standards = (['int','short','char','long','unsigned','signed'] + cfg.treat_as.keys).uniq + @standards = (%w[int short char long unsigned signed] + cfg.treat_as.keys).uniq @array_size_name = cfg.array_size_name - @array_size_type = (['int', 'size_t'] + cfg.array_size_type).uniq + @array_size_type = (%w[int size_t] + cfg.array_size_type).uniq @when_no_prototypes = cfg.when_no_prototypes @local_as_void = @treat_as_void @verbosity = cfg.verbosity @treat_externs = cfg.treat_externs @treat_inlines = cfg.treat_inlines @inline_function_patterns = cfg.inline_function_patterns - @c_strippables += ['extern'] if (@treat_externs == :include) #we'll need to remove the attribute if we're allowing externs - @c_strippables += ['inline'] if (@treat_inlines == :include) #we'll need to remove the attribute if we're allowing inlines + @c_strippables += ['extern'] if @treat_externs == :include # we'll need to remove the attribute if we're allowing externs + @c_strippables += ['inline'] if @treat_inlines == :include # we'll need to remove the attribute if we're allowing inlines end def parse(name, source) - @module_name = name.gsub(/\W/,'') + @module_name = name.gsub(/\W/, '') @typedefs = [] @funcs = [] @normalized_source = nil function_names = [] - parse_functions( import_source(source) ).map do |decl| + parse_functions(import_source(source)).map do |decl| func = parse_declaration(decl) - unless (function_names.include? func[:name]) + unless function_names.include? func[:name] @funcs << func function_names << func[:name] end end - @normalized_source = if (@treat_inlines == :include) + @normalized_source = if @treat_inlines == :include transform_inline_functions(source) else '' @@ -55,24 +54,23 @@ class CMockHeaderParser { :includes => nil, :functions => @funcs, :typedefs => @typedefs, - :normalized_source => @normalized_source - } + :normalized_source => @normalized_source } end private if $ThisIsOnlyATest.nil? ################ def remove_nested_pairs_of_braces(source) # remove nested pairs of braces because no function declarations will be inside of them (leave outer pair for function definition detection) - if (RUBY_VERSION.split('.')[0].to_i > 1) - #we assign a string first because (no joke) if Ruby 1.9.3 sees this line as a regex, it will crash. - r = "\\{([^\\{\\}]*|\\g<0>)*\\}" + if RUBY_VERSION.split('.')[0].to_i > 1 + # we assign a string first because (no joke) if Ruby 1.9.3 sees this line as a regex, it will crash. + r = '\\{([^\\{\\}]*|\\g<0>)*\\}' source.gsub!(/#{r}/m, '{ }') else while source.gsub!(/\{[^\{\}]*\{[^\{\}]*\}[^\{\}]*\}/m, '{ }') end end - return source + source end # Return the number of pairs of braces/square brackets in the function provided by the user @@ -83,22 +81,22 @@ class CMockHeaderParser total_pairs = 0 source.each_char do |c| - if ("{" == c) + if c == '{' curr_level += 1 - total_pairs +=1 + total_pairs += 1 is_function_start_found = true - elsif ("}" == c) - curr_level -=1 + elsif c == '}' + curr_level -= 1 end - break if is_function_start_found && curr_level == 0 # We reached the end of the inline function body + break if is_function_start_found && curr_level == 0 # We reached the end of the inline function body end - if 0 != curr_level - total_pairs = 0 # Something is fishy about this source, not enough closing braces? + if curr_level != 0 + total_pairs = 0 # Something is fishy about this source, not enough closing braces? end - return total_pairs + total_pairs end # Transform inline functions to regular functions in the source by the user @@ -117,7 +115,7 @@ class CMockHeaderParser end # 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) + source = source.force_encoding('ISO-8859-1').encode('utf-8', :replace => nil) # smush multiline macros into single line (checking for continuation character at end of line '\') # If the user uses a macro to declare an inline function, @@ -141,15 +139,15 @@ class CMockHeaderParser loop do inline_function_match = source.match(/#{format}/) # Search for inline function declaration - break if nil == inline_function_match # No inline functions so nothing to do + break if inline_function_match.nil? # No inline functions so nothing to do # 1. Determine if we are dealing with a user defined macro to declare inline functions # If the end of the pre-match string is a macro-declaration-like string, # we are dealing with a user defined macro to declare inline functions 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_pre_match = inline_function_match.pre_match.sub(/(#define\s*)\z/, '') + stripped_post_match = inline_function_match.post_match.sub(/\A(.*[\n]?)/, '') source = stripped_pre_match + stripped_post_match next end @@ -167,25 +165,24 @@ class CMockHeaderParser # Remove the function body to transform it into a 'normal' function. total_pairs_to_remove = count_number_of_pairs_of_braces_in_function(inline_function_match.post_match) - break if 0 == total_pairs_to_remove # Bad source? + break if total_pairs_to_remove == 0 # Bad source? inline_function_stripped = inline_function_match.post_match total_pairs_to_remove.times do - inline_function_stripped.sub!(/\s*#{square_bracket_pair_regex_format}/, ";") # Remove inline implementation (+ some whitespace because it's prettier) + inline_function_stripped.sub!(/\s*#{square_bracket_pair_regex_format}/, ';') # Remove inline implementation (+ some whitespace because it's prettier) end source = inline_function_match.pre_match + inline_function_stripped # Make new source with the inline function removed and move on to the next end end - return source + source end def import_source(source) - # 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) + 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 @@ -197,16 +194,16 @@ class CMockHeaderParser # If user wants to mock inline functions, # remove the (user specific) inline keywords before removing anything else to avoid missing an inline function - if (@treat_inlines == :include) - @inline_function_patterns.each { |user_format_string| + if @treat_inlines == :include + @inline_function_patterns.each do |user_format_string| source.gsub!(/#{user_format_string}/, '') # remove user defined inline function patterns - } + end end # smush multiline macros into single line (checking for continuation character at end of line '\') source.gsub!(/\s*\\\s*/m, ' ') - #remove comments (block and line, in three steps to ensure correct precedence) + # remove comments (block and line, in three steps to ensure correct precedence) source.gsub!(/(? * , <@array_size_type> <@array_size_name> - args.each_with_index {|val, index| + args.each_with_index do |val, index| next_index = index + 1 - if (args.length > next_index) - if (val[:ptr?] == true and args[next_index][:name].match(@array_size_name) and @array_size_type.include?(args[next_index][:type])) - val[:array_data?] = true - args[next_index][:array_size?] = true - end - end - } + next unless args.length > next_index - return args + if (val[:ptr?] == true) && args[next_index][:name].match(@array_size_name) && @array_size_type.include?(args[next_index][:type]) + val[:array_data?] = true + args[next_index][:array_size?] = true + end + end + + args end def divine_ptr(arg) return false unless arg.include? '*' # treat "const char *" and similar as a string, not a pointer return false if /(^|\s)(const\s+)?char(\s+const)?\s*\*(?!.*\*)/ =~ arg - return true + + true end def divine_const(arg) # a non-pointer arg containing "const" is a constant # an arg containing "const" before the last * is a pointer to a constant - return ( arg.include?('*') ? (/(^|\s|\*)const(\s(\w|\s)*)?\*(?!.*\*)/ =~ arg) - : (/(^|\s)const(\s|$)/ =~ arg) ) ? true : false + (arg.include?('*') ? (/(^|\s|\*)const(\s(\w|\s)*)?\*(?!.*\*)/ =~ arg) + : (/(^|\s)const(\s|$)/ =~ arg) + ) ? true : false end def divine_ptr_and_const(arg) @@ -381,14 +379,14 @@ class CMockHeaderParser divination[:const?] = divine_const(arg) # an arg containing "const" after the last * is a constant pointer - divination[:const_ptr?] = (/\*(?!.*\*)\s*const(\s|$)/ =~ arg) ? true : false + divination[:const_ptr?] = /\*(?!.*\*)\s*const(\s|$)/ =~ arg ? true : false - return divination + divination end def clean_args(arg_list) - if ((@local_as_void.include?(arg_list.strip)) or (arg_list.empty?)) - return 'void' + if @local_as_void.include?(arg_list.strip) || arg_list.empty? + 'void' else c = 0 # magically turn brackets into asterisks, also match for parentheses that come from macros @@ -399,48 +397,46 @@ 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\*]+)\(+\s*\*[\*\s]*([\w\s]*)\s*\)+\s*\(((?:[\w\s\*]*,?)*)\s*\)*/) do |_m| functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}" - funcret = $1.strip - funcname = $2.strip - funcargs = $3.strip + funcret = Regexp.last_match(1).strip + funcname = Regexp.last_match(2).strip + funcargs = Regexp.last_match(3).strip funconst = '' - if (funcname.include? 'const') - funcname.gsub!('const','').strip! + if funcname.include? 'const' + funcname.gsub!('const', '').strip! funconst = 'const ' end @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});" - funcname = "cmock_arg#{c+=1}" if (funcname.empty?) + 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| - + # 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}" - funcret = $1.strip - funcname = $2.strip - funcargs = $3.strip + funcret = Regexp.last_match(1).strip + funcname = Regexp.last_match(2).strip + funcargs = Regexp.last_match(3).strip funconst = '' - if (funcname.include? 'const') - funcname.gsub!('const','').strip! + if funcname.include? 'const' + funcname.gsub!('const', '').strip! funconst = 'const ' end @typedefs << "typedef #{funcret}(*#{functype})(#{funcargs});" - funcname = "cmock_arg#{c+=1}" if (funcname.empty?) + funcname = "cmock_arg#{c += 1}" if funcname.empty? "#{functype} #{funconst}#{funcname}" end - #automatically name unnamed arguments (those that only had a type) - arg_list.split(/\s*,\s*/).map { |arg| + # automatically name unnamed arguments (those that only had a type) + arg_list.split(/\s*,\s*/).map do |arg| parts = (arg.split - ['struct', 'union', 'enum', 'const', 'const*']) - if ((parts.size < 2) or (parts[-1][-1].chr == '*') or (@standards.include?(parts[-1]))) - "#{arg} cmock_arg#{c+=1}" + if (parts.size < 2) || (parts[-1][-1].chr == '*') || @standards.include?(parts[-1]) + "#{arg} cmock_arg#{c += 1}" else arg end - }.join(', ') + end.join(', ') end end @@ -450,10 +446,10 @@ class CMockHeaderParser regex_match = @declaration_parse_matcher.match(declaration) raise "Failed parsing function declaration: '#{declaration}'" if regex_match.nil? - #grab argument list + # grab argument list args = regex_match[2].strip - #process function attributes, return type, and name + # process function attributes, return type, and name parsed = parse_type_and_name(regex_match[1]) decl[:name] = parsed[:name] @@ -463,66 +459,64 @@ class CMockHeaderParser end rettype = parsed[:type] - rettype = 'void' if (@local_as_void.include?(rettype.strip)) + rettype = 'void' if @local_as_void.include?(rettype.strip) decl[:return] = { :type => rettype, :name => 'cmock_to_return', :str => "#{rettype} cmock_to_return", :void? => (rettype == 'void'), - :ptr? => parsed[:ptr?], - :const? => parsed[:const?], - :const_ptr? => parsed[:const_ptr?] - } + :ptr? => parsed[:ptr?] || false, + :const? => parsed[:const?] || false, + :const_ptr? => parsed[:const_ptr?] || false } - #remove default argument statements from mock definitions + # remove default argument statements from mock definitions args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ') - #check for var args - if (args =~ /\.\.\./) - decl[:var_arg] = args.match( /[\w\s]*\.\.\./ ).to_s.strip - if (args =~ /\,[\w\s]*\.\.\./) - args = args.gsub!(/\,[\w\s]*\.\.\./,'') - else - args = 'void' - end + # 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]*\.\.\./, '') + else + 'void' + end else decl[:var_arg] = nil end args = clean_args(args) decl[:args_string] = args decl[:args] = parse_args(args) - decl[:args_call] = decl[:args].map{|a| a[:name]}.join(', ') - decl[:contains_ptr?] = decl[:args].inject(false) {|ptr, arg| arg[:ptr?] ? true : ptr } + decl[:args_call] = decl[:args].map { |a| a[:name] }.join(', ') + decl[:contains_ptr?] = decl[:args].inject(false) { |ptr, arg| arg[:ptr?] ? true : ptr } - if (decl[:return][:type].nil? or decl[:name].nil? or decl[:args].nil? or - decl[:return][:type].empty? or decl[:name].empty?) - raise "Failed Parsing Declaration Prototype!\n" + - " declaration: '#{declaration}'\n" + - " modifier: '#{decl[:modifier]}'\n" + - " return: #{prototype_inspect_hash(decl[:return])}\n" + - " function: '#{decl[:name]}'\n" + - " args: #{prototype_inspect_array_of_hashes(decl[:args])}\n" + if decl[:return][:type].nil? || decl[:name].nil? || decl[:args].nil? || + decl[:return][:type].empty? || decl[:name].empty? + raise "Failed Parsing Declaration Prototype!\n" \ + " declaration: '#{declaration}'\n" \ + " modifier: '#{decl[:modifier]}'\n" \ + " return: #{prototype_inspect_hash(decl[:return])}\n" \ + " function: '#{decl[:name]}'\n" \ + " args: #{prototype_inspect_array_of_hashes(decl[:args])}\n" end - return decl + decl end def prototype_inspect_hash(hash) pairs = [] - hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if (value.class == String)}#{value}#{"'" if (value.class == String)}" } - return "{#{pairs.join(', ')}}" + hash.each_pair { |name, value| pairs << ":#{name} => #{"'" if value.class == String}#{value}#{"'" if value.class == String}" } + "{#{pairs.join(', ')}}" end def prototype_inspect_array_of_hashes(array) hashes = [] array.each { |hash| hashes << prototype_inspect_hash(hash) } - case (array.size) + case array.size when 0 - return "[]" + return '[]' when 1 return "[#{hashes[0]}]" else return "[\n #{hashes.join("\n ")}\n ]\n" end end - end diff --git a/lib/cmock_plugin_manager.rb b/lib/cmock_plugin_manager.rb index cc5ced2..bc7be48 100644 --- a/lib/cmock_plugin_manager.rb +++ b/lib/cmock_plugin_manager.rb @@ -4,10 +4,7 @@ # [Released under MIT License. Please refer to license.txt for details] # ========================================== -require 'thread' - class CMockPluginManager - attr_accessor :plugins def initialize(config, utils) @@ -15,41 +12,39 @@ 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.plugin_require_mutex.synchronize { load_plugin(plugin_name, object_name, config, utils) } end - @plugins.sort! {|a,b| a.priority <=> b.priority } + @plugins.sort! { |a, b| a.priority <=> b.priority } end - def run(method, args=nil) + def run(method, args = nil) if args.nil? - return @plugins.collect{ |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join + @plugins.collect { |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join else - return @plugins.collect{ |plugin| plugin.send(method, args) if plugin.respond_to?(method) }.flatten.join + @plugins.collect { |plugin| plugin.send(method, args) if plugin.respond_to?(method) }.flatten.join end end def camelize(lower_case_and_underscored_word) - lower_case_and_underscored_word.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase } + lower_case_and_underscored_word.gsub(/\/(.?)/) { '::' + Regexp.last_match(1).upcase }.gsub(/(^|_)(.)/) { Regexp.last_match(2).upcase } end - + private - + def self.plugin_require_mutex @mutex ||= Mutex.new end - + def load_plugin(plugin_name, object_name, config, utils) - begin - unless (Object.const_defined? object_name) - file_name = "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb" - require file_name - end - class_name = Object.const_get(object_name) - @plugins << class_name.new(config, utils) - rescue - file_name = "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb" - raise "ERROR: CMock unable to load plugin '#{plugin_name}' '#{object_name}' #{file_name}" + unless Object.const_defined? object_name + file_name = "#{__dir__}/cmock_generator_plugin_#{plugin_name.downcase}.rb" + require file_name end + class_name = Object.const_get(object_name) + @plugins << class_name.new(config, utils) + rescue StandardError + file_name = "#{__dir__}/cmock_generator_plugin_#{plugin_name.downcase}.rb" + raise "ERROR: CMock unable to load plugin '#{plugin_name}' '#{object_name}' #{file_name}" end end diff --git a/lib/cmock_unityhelper_parser.rb b/lib/cmock_unityhelper_parser.rb index c22db7a..d30d322 100644 --- a/lib/cmock_unityhelper_parser.rb +++ b/lib/cmock_unityhelper_parser.rb @@ -2,12 +2,11 @@ # CMock Project - Automatic Mock Generation for C # Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams # [Released under MIT License. Please refer to license.txt for details] -# ========================================== +# ========================================== class CMockUnityHelperParser - attr_accessor :c_types - + def initialize(config) @config = config @fallback = @config.plugins.include?(:array) ? 'UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY' : 'UNITY_TEST_ASSERT_EQUAL_MEMORY' @@ -15,61 +14,64 @@ class CMockUnityHelperParser end def get_helper(ctype) - lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/,'\1\3\5\6').strip.gsub(/\s+/,'_') - return [@c_types[lookup], ''] if (@c_types[lookup]) - if (lookup =~ /\*$/) - lookup = lookup.gsub(/\*$/,'') - return [@c_types[lookup], '*'] if (@c_types[lookup]) + lookup = ctype.gsub(/(?:^|(\S?)(\s*)|(\W))const(?:$|(\s*)(\S)|(\W))/, '\1\3\5\6').strip.gsub(/\s+/, '_') + return [@c_types[lookup], ''] if @c_types[lookup] + + if lookup =~ /\*$/ + lookup = lookup.gsub(/\*$/, '') + return [@c_types[lookup], '*'] if @c_types[lookup] else - lookup = lookup + '*' - return [@c_types[lookup], '&'] if (@c_types[lookup]) + lookup += '*' + return [@c_types[lookup], '&'] if @c_types[lookup] end - return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if (ctype =~ /cmock_\w+_ptr\d+/) + return ['UNITY_TEST_ASSERT_EQUAL_PTR', ''] if ctype =~ /cmock_\w+_ptr\d+/ raise("Don't know how to test #{ctype} and memory tests are disabled!") unless @config.memcmp_if_unknown - return (lookup =~ /\*$/) ? [@fallback, '&'] : [@fallback, ''] + + lookup =~ /\*$/ ? [@fallback, '&'] : [@fallback, ''] end - + private ########################### - + def map_C_types c_types = {} @config.treat_as.each_pair do |ctype, expecttype| - c_type = ctype.gsub(/\s+/,'_') - if (expecttype =~ /\*/) - c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/,'')}_ARRAY" + c_type = ctype.gsub(/\s+/, '_') + if expecttype =~ /\*/ + c_types[c_type] = "UNITY_TEST_ASSERT_EQUAL_#{expecttype.gsub(/\*/, '')}_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 end - + def import_source source = @config.load_unity_helper return {} if source.nil? + c_types = {} - source = source.gsub(/\/\/.*$/, '') #remove line comments - source = source.gsub(/\/\*.*?\*\//m, '') #remove block comments - - #scan for comparison helpers - match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4,'\s*\w+\s*').join(',') + '\)') + source = source.gsub(/\/\/.*$/, '') # remove line comments + source = source.gsub(/\/\*.*?\*\//m, '') # remove block comments + + # scan for comparison helpers + match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+))\s*\(' + Array.new(4, '\s*\w+\s*').join(',') + '\)') pairs = source.scan(match_regex).flatten.compact - (pairs.size/2).times do |i| - expect = pairs[i*2] - ctype = pairs[(i*2)+1] - c_types[ctype] = expect unless expect.include?("_ARRAY") + (pairs.size / 2).times do |i| + expect = pairs[i * 2] + ctype = pairs[(i * 2) + 1] + c_types[ctype] = expect unless expect.include?('_ARRAY') end - - #scan for array variants of those helpers - match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5,'\s*\w+\s*').join(',') + '\)') + + # scan for array variants of those helpers + match_regex = Regexp.new('^\s*#define\s+(UNITY_TEST_ASSERT_EQUAL_(\w+_ARRAY))\s*\(' + Array.new(5, '\s*\w+\s*').join(',') + '\)') pairs = source.scan(match_regex).flatten.compact - (pairs.size/2).times do |i| - expect = pairs[i*2] - ctype = pairs[(i*2)+1] - c_types[ctype.gsub('_ARRAY','*')] = expect + (pairs.size / 2).times do |i| + expect = pairs[i * 2] + ctype = pairs[(i * 2) + 1] + c_types[ctype.gsub('_ARRAY', '*')] = expect end - + c_types end end diff --git a/scripts/create_makefile.rb b/scripts/create_makefile.rb index e8cc6bf..df7ca2e 100644 --- a/scripts/create_makefile.rb +++ b/scripts/create_makefile.rb @@ -20,7 +20,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}/.freeze [TEST_BUILD_DIR, OBJ_DIR, RUNNERS_DIR, MOCKS_DIR, TEST_BIN_DIR].each do |dir| FileUtils.mkdir_p dir @@ -28,33 +28,32 @@ end all_headers_to_mock = [] -suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].upcase == "--SILENT") - -File.open(TEST_MAKEFILE, "w") do |mkfile| +suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].upcase == '--SILENT') +File.open(TEST_MAKEFILE, 'w') do |mkfile| # Define make variables - mkfile.puts "CC ?= gcc" + mkfile.puts 'CC ?= gcc' mkfile.puts "BUILD_DIR = #{BUILD_DIR}" mkfile.puts "SRC_DIR = #{SRC_DIR}" mkfile.puts "TEST_DIR = #{TEST_DIR}" - mkfile.puts "TEST_CFLAGS ?= -DTEST" + mkfile.puts 'TEST_CFLAGS ?= -DTEST' mkfile.puts "CMOCK_DIR ?= #{CMOCK_DIR}" mkfile.puts "UNITY_DIR ?= #{UNITY_DIR}" - mkfile.puts "TEST_BUILD_DIR ?= ${BUILD_DIR}/test" - mkfile.puts "TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport" - mkfile.puts "OBJ ?= ${BUILD_DIR}/obj" - mkfile.puts "OBJ_DIR = ${OBJ}" - mkfile.puts "" + mkfile.puts 'TEST_BUILD_DIR ?= ${BUILD_DIR}/test' + mkfile.puts 'TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport' + mkfile.puts 'OBJ ?= ${BUILD_DIR}/obj' + mkfile.puts 'OBJ_DIR = ${OBJ}' + mkfile.puts '' # Build Unity mkfile.puts "#{UNITY_OBJ}: #{UNITY_SRC}/unity.c" mkfile.puts "\t${CC} -o $@ -c $< -I #{UNITY_SRC}" - mkfile.puts "" + mkfile.puts '' # Build CMock mkfile.puts "#{CMOCK_OBJ}: #{CMOCK_SRC}/cmock.c" mkfile.puts "\t${CC} -o $@ -c $< -I #{UNITY_SRC} -I #{CMOCK_SRC}" - mkfile.puts "" + mkfile.puts '' test_sources = Dir["#{TEST_DIR}/**/test_*.c"] test_targets = [] @@ -69,7 +68,8 @@ File.open(TEST_MAKEFILE, "w") do |mkfile| if MOCK_SUFFIX.empty? return filename.start_with? MOCK_PREFIX end - return (filename.start_with? MOCK_PREFIX or filename.end_with? MOCK_SUFFIX) + + (filename.start_with?(MOCK_PREFIX) || filename.end_with?(MOCK_SUFFIX)) end all_headers = all_headers.reject { |f| reject_mock_files(f) } @@ -93,56 +93,58 @@ File.open(TEST_MAKEFILE, "w") do |mkfile| # Build main project modules, with TEST defined module_src = File.join(SRC_DIR, "#{src_module_name}.c") module_obj = File.join(OBJ_DIR, "#{src_module_name}.o") - if not makefile_targets.include? module_obj - makefile_targets.push(module_obj) - mkfile.puts "#{module_obj}: #{module_src}" - mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}" - mkfile.puts "" + unless makefile_targets.include? module_obj + makefile_targets.push(module_obj) + mkfile.puts "#{module_obj}: #{module_src}" + mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}" + mkfile.puts '' end # process link-only files linkonly = cfg[:includes][:linkonly] linkonly_objs = [] linkonly.each do |linkonlyfile| - linkonlybase = File.basename(linkonlyfile,".*") - linkonlymodule_src = File.join(SRC_DIR, "#{linkonlyfile}") - linkonlymodule_obj = File.join(OBJ_DIR, "#{linkonlybase}.o") - linkonly_objs.push(linkonlymodule_obj) - #only create the target if we didn't already - if not makefile_targets.include? linkonlymodule_obj - makefile_targets.push(linkonlymodule_obj) - mkfile.puts "#{linkonlymodule_obj}: #{linkonlymodule_src}" - mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}" - mkfile.puts "" - end + linkonlybase = File.basename(linkonlyfile, '.*') + linkonlymodule_src = File.join(SRC_DIR, linkonlyfile.to_s) + linkonlymodule_obj = File.join(OBJ_DIR, "#{linkonlybase}.o") + linkonly_objs.push(linkonlymodule_obj) + # only create the target if we didn't already + next if makefile_targets.include? linkonlymodule_obj + + makefile_targets.push(linkonlymodule_obj) + mkfile.puts "#{linkonlymodule_obj}: #{linkonlymodule_src}" + mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I ${SRC_DIR} ${INCLUDE_PATH}" + mkfile.puts '' end # Create runners mkfile.puts "#{runner_source}: #{test}" mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/create_runner.rb #{test} #{runner_source}" - mkfile.puts "" + mkfile.puts '' # Build runner mkfile.puts "#{runner_obj}: #{runner_source}" mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{MOCKS_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}" - mkfile.puts "" + mkfile.puts '' # Collect mocks to generate - system_mocks = cfg[:includes][:system].select{|name| name =~ MOCK_MATCHER} - raise "Mocking of system headers is not yet supported!" if !system_mocks.empty? - local_mocks = cfg[:includes][:local].select{|name| name =~ MOCK_MATCHER} + system_mocks = cfg[:includes][:system].select { |name| name =~ MOCK_MATCHER } + raise 'Mocking of system headers is not yet supported!' unless system_mocks.empty? - module_names_to_mock = local_mocks.map{|name| "#{name.sub(/#{MOCK_PREFIX}/,'')}"} + local_mocks = cfg[:includes][:local].select { |name| name =~ MOCK_MATCHER } + + module_names_to_mock = local_mocks.map { |name| name.sub(/#{MOCK_PREFIX}/, '').to_s } headers_to_mock = [] module_names_to_mock.each do |name| header_to_mock = nil all_headers.each do |header| - if (header =~ /[\/\\]?#{name}$/) + if header =~ /[\/\\]?#{name}$/ header_to_mock = header break end end raise "Module header '#{name}' not found to mock!" unless header_to_mock + headers_to_mock << header_to_mock end @@ -156,18 +158,18 @@ File.open(TEST_MAKEFILE, "w") do |mkfile| # Build test suite mkfile.puts "#{test_obj}: #{test} #{module_obj} #{mock_objs.join(' ')}" mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} -I #{MOCKS_DIR} ${INCLUDE_PATH}" - mkfile.puts "" + mkfile.puts '' # Build test suite executable test_objs = "#{test_obj} #{runner_obj} #{module_obj} #{mock_objs.join(' ')} #{linkonly_objs.join(' ')} #{UNITY_OBJ} #{CMOCK_OBJ}" mkfile.puts "#{test_bin}: #{test_objs}" mkfile.puts "\t${CC} -o $@ ${LDFLAGS} #{test_objs}" - mkfile.puts "" + mkfile.puts '' # Run test suite and generate report mkfile.puts "#{test_results}: #{test_bin}" mkfile.puts "\t-#{test_bin} > #{test_results} 2>&1" - mkfile.puts "" + mkfile.puts '' test_targets << test_bin end @@ -181,22 +183,21 @@ File.open(TEST_MAKEFILE, "w") do |mkfile| mkfile.puts "#{mock_src}: #{hdr}" mkfile.puts "\t@CMOCK_DIR=${CMOCK_DIR} ruby ${CMOCK_DIR}/scripts/create_mock.rb #{hdr}" - mkfile.puts "" + mkfile.puts '' mkfile.puts "#{mock_obj}: #{mock_src} #{mock_header}" mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{MOCKS_DIR} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}" - mkfile.puts "" + mkfile.puts '' end # Create test summary task - mkfile.puts "test_summary:" + mkfile.puts 'test_summary:' mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/test_summary.rb #{suppress_error ? '--silent' : ''}" - mkfile.puts "" - mkfile.puts ".PHONY: test_summary" - mkfile.puts "" + mkfile.puts '' + mkfile.puts '.PHONY: test_summary' + mkfile.puts '' # Create target to run all tests - mkfile.puts "test: #{test_targets.map{|t| t + '.testresult'}.join(' ')} test_summary" - mkfile.puts "" - + mkfile.puts "test: #{test_targets.map { |t| t + '.testresult' }.join(' ')} test_summary" + mkfile.puts '' end diff --git a/scripts/create_mock.rb b/scripts/create_mock.rb index c72e64b..93107a9 100644 --- a/scripts/create_mock.rb +++ b/scripts/create_mock.rb @@ -1,8 +1,8 @@ require "#{ENV['CMOCK_DIR']}/lib/cmock" -raise "Header file to mock must be specified!" unless ARGV.length >= 1 +raise 'Header file to mock must be specified!' unless ARGV.length >= 1 mock_out = ENV.fetch('MOCK_OUT', './build/test/mocks') mock_prefix = ENV.fetch('MOCK_PREFIX', 'mock_') -cmock = CMock.new({:plugins => [:ignore, :return_thru_ptr], :mock_prefix => mock_prefix, :mock_path => mock_out}) +cmock = CMock.new(:plugins => %i[ignore return_thru_ptr], :mock_prefix => mock_prefix, :mock_path => mock_out) cmock.setup_mocks(ARGV[0]) diff --git a/scripts/create_runner.rb b/scripts/create_runner.rb index 82ceada..23bf23d 100644 --- a/scripts/create_runner.rb +++ b/scripts/create_runner.rb @@ -1,13 +1,12 @@ -if ($0 == __FILE__) +if $0 == __FILE__ - #make sure there is at least one parameter left (the input file) + # make sure there is at least one parameter left (the input file) if ARGV.length < 2 puts ["\nusage: ruby #{__FILE__} input_test_file (output)", - "", - " input_test_file - this is the C file you want to create a runner for", - " output - this is the name of the runner file to generate", - " defaults to (input_test_file)_Runner", - ].join("\n") + '', + ' input_test_file - this is the C file you want to create a runner for', + ' output - this is the name of the runner file to generate', + ' defaults to (input_test_file)_Runner'].join("\n") exit 1 end diff --git a/scripts/test_summary.rb b/scripts/test_summary.rb index ebf8524..c6abf21 100644 --- a/scripts/test_summary.rb +++ b/scripts/test_summary.rb @@ -1,5 +1,4 @@ - -suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].upcase == "--SILENT") +suppress_error = !ARGV.nil? && !ARGV.empty? && (ARGV[0].upcase == '--SILENT') begin require "#{ENV['UNITY_DIR']}/auto/unity_test_summary.rb" diff --git a/test/rakefile b/test/rakefile index beae525..06dc98f 100644 --- a/test/rakefile +++ b/test/rakefile @@ -107,3 +107,36 @@ end task :no_color do $colour_output = false end + +################### CODING STYLE VALIDATION +namespace :style do + desc "Check style" + task :check do + report "\nVERIFYING RUBY STYLE" + report execute("rubocop ../lib ../examples ../config ../scripts --config ../vendor/unity/test/.rubocop.yml", true) + report "Styling Ruby:PASS" + end + + desc "Fix Style of all C Code" + task :c do + run_astyle("../src/*.* ../extras/fixture/src/*.*") + end + + desc "Attempt to Autocorrect style" + task :auto => ['style:clean'] do + report execute("rubocop ../lib ../examples ../config ../scripts --auto-correct --config ../vendor/unity/test/.rubocop.yml", true) + report "Autocorrected What We Could." + end + + desc "Update style todo list" + task :todo => ['style:clean'] do + report execute("rubocop ../lib ../examples ../config ../scripts --auto-gen-config --config ../vendor/unity/test/.rubocop.yml", true) + report "Updated Style TODO List." + end + + task :clean do + File.delete(".rubocop_todo.yml") if File.exists?(".rubocop_todo.yml") + end +end + +task :style => ['style:check'] \ No newline at end of file diff --git a/test/rakefile_helper.rb b/test/rakefile_helper.rb index 4481696..4c940ad 100644 --- a/test/rakefile_helper.rb +++ b/test/rakefile_helper.rb @@ -161,6 +161,18 @@ module RakefileHelpers end end + def run_astyle(style_what) + report "Styling C Code..." + command = "AStyle " \ + "--style=allman --indent=spaces=4 --indent-switches --indent-preproc-define --indent-preproc-block " \ + "--pad-oper --pad-comma --unpad-paren --pad-header " \ + "--align-pointer=type --align-reference=name " \ + "--add-brackets --mode=c --suffix=none " \ + "#{style_what}" + execute(command, false) + report "Styling C:PASS" + end + def report_summary summary = UnityTestSummary.new summary.root = File.expand_path(File.dirname(__FILE__)) + '/' diff --git a/test/unit/cmock_header_parser_test.rb b/test/unit/cmock_header_parser_test.rb index 56683a2..ccc00f4 100644 --- a/test/unit/cmock_header_parser_test.rb +++ b/test/unit/cmock_header_parser_test.rb @@ -1035,7 +1035,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do { :type=>"int", :name => "param8", :ptr? => false, :const? => true, :const_ptr? => false }], :args_call => "param1, param2, param3, param4, param5, param6, param7, param8", :contains_ptr? => true - }] + }].freeze assert_equal(expected, @parser.parse("module", source)[:functions]) end