Merge pull request #255 from jlindgren90/master

Add documentation for :array_size_type and :array_size_name.

.travis.yml

@@ -1,29 +1,28 @@
 language: ruby
 
-os: 
-  - osx
+os:
   - linux
-      
+
 rvm:
-  - "2.0.0"
-  - "2.2.2"
-  
+  - "2.3"
+  - "2.4"
+  - "2.6"
+
 before_install:
-  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then rvm install 2.1 && rvm use 2.1 && ruby -v; fi
-  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --assume-yes --quiet gcc-multilib; fi
-  
+  - sudo apt-get install --assume-yes --quiet gcc-multilib
+
 install:
   - bundle install
   - gem install rspec
-  - gem install rubocop
-  
+  - gem install rubocop -v 0.57.2
+
 script:
   - cd test && rake ci
   - cd ..
   - cd examples && cd make_example
-  - make clean 
-  - make setup 
+  - make clean
+  - make setup
   - make test
   - cd ..
-  - cd temp_sensor 
+  - cd temp_sensor
   - rake ci

README.md

@@ -7,17 +7,18 @@ Getting Started
 ================
 
 If you're using Ceedling, there is no need to install CMock. It will handle it for you.
-For everyone else, the simplest way is to grab it off github. You can also download it 
+For everyone else, the simplest way is to grab it off github. You can also download it
 as a zip if you prefer. The Github method looks something like this:
 
     > git clone --recursive https://github.com/throwtheswitch/cmock.git
     > cd cmock
     > bundle install # Ensures you have all RubyGems needed
-    
+
 If you plan to help with the development of CMock (or just want to verify that it can
 perform its self tests on your system) then you can enter the test directory and then
 ask it to test:
-    
+
+    > cd test
     > rake # Run all CMock self tests
 
 API Documentation

docs/CMock_Summary.md

@@ -68,15 +68,15 @@ Installing
 ==========
 
 The first thing you need to do to install CMock is to get yourself
-a copy of Ruby. If you're on linux or osx, you probably already 
+a copy of Ruby. If you're on linux or osx, you probably already
 have it. You can prove it by typing the following:
 
     ruby --version
-    
+
 
 If it replied in a way that implies ignorance, then you're going to
-need to install it. You can go to [ruby-lang](https://ruby-lang.org) 
-to get the latest version. You're also going to need to do that if it 
+need to install it. You can go to [ruby-lang](https://ruby-lang.org)
+to get the latest version. You're also going to need to do that if it
 replied with a version that is older than 2.0.0. Go ahead. We'll wait.
 
 Once you have Ruby, you have three options:
@@ -117,23 +117,23 @@ ExpectAnyArgs:
 This behaves just like the Expects calls, except that it doesn't really
 care what the arguments are that the mock gets called with. It still counts
 the number of times the mock is called and it still handles return values
-if there are some.
+if there are some. Note that an ExpectAnyArgs call is not generated for
+functions that have no arguments, because it would act exactly like the existing
+Expect and ExpectAndReturn calls.
 
-* `void func(void)` => `void func_ExpectAnyArgs(void)`
 * `void func(params)` => `void func_ExpectAnyArgs(void)`
-* `retval func(void)` => `void func_ExpectAnyArgsAndReturn(retval_to_return)`
 * `retval func(params)` => `void func_ExpectAnyArgsAndReturn(retval_to_return)`
 
 
 Array:
 ------
 
-An ExpectWithArray is another variant of Expect. Like expect, it cares about 
-the number of times a mock is called, the arguments it is called with, and the 
-values it is to return. This variant has another feature, though. For anything 
-that resembles a pointer or array, it breaks the argument into TWO arguments. 
+An ExpectWithArray is another variant of Expect. Like expect, it cares about
+the number of times a mock is called, the arguments it is called with, and the
+values it is to return. This variant has another feature, though. For anything
+that resembles a pointer or array, it breaks the argument into TWO arguments.
 The first is the original pointer. The second specify the number of elements
-it is to verify of that array. If you specify 1, it'll check one object. If 2, 
+it is to verify of that array. If you specify 1, it'll check one object. If 2,
 it'll assume your pointer is pointing at the first of two elements in an array.
 If you specify zero elements, it will check just the pointer if
 `:smart` mode is configured or fail if `:compare_data` is set.
@@ -151,9 +151,9 @@ Maybe you don't care about the number of times a particular function is called o
 the actual arguments it is called with. In that case, you want to use Ignore. Ignore
 only needs to be called once per test. It will then ignore any further calls to that
 particular mock. The IgnoreAndReturn works similarly, except that it has the added
-benefit of knowing what to return when that call happens. If the mock is called more 
+benefit of knowing what to return when that call happens. If the mock is called more
 times than IgnoreAndReturn was called, it will keep returning the last value without
-complaint. If it's called less times, it will also ignore that. You SAID you didn't 
+complaint. If it's called fewer times, it will also ignore that. You SAID you didn't
 care how many times it was called, right?
 
 * `void func(void)` => `void func_Ignore(void)`
@@ -168,9 +168,11 @@ Ignore Arg:
 Maybe you overall want to use Expect and its similar variations, but you don't care
 what is passed to a particular argument. This is particularly useful when that argument
 is a pointer to a value that is supposed to be filled in by the function. You don't want
-to use ExpectAnyArgs, because you still care about the other arguments. Instead, before
-any of your Expect calls are made, you can call this function. It tells CMock to ignore
-a particular argument for the rest of this test, for this mock function.
+to use ExpectAnyArgs, because you still care about the other arguments. Instead, after
+an Expect call is made, you can call this function. It tells CMock to ignore
+a particular argument for the rest of this test, for this mock function. You may call
+multiple instances of this to ignore multiple arguments after each expectation if
+desired.
 
 * `void func(params)` => `void func_IgnoreArg_paramName(void)`
 
@@ -179,7 +181,7 @@ ReturnThruPtr:
 --------------
 
 Another option which operates on a particular argument of a function is the ReturnThruPtr
-plugin. For every argument that resembles a pointer or reference, CMock generates an 
+plugin. For every argument that resembles a pointer or reference, CMock generates an
 instance of this function. Just as the AndReturn functions support injecting one or more
 return values into a queue, this function lets you specify one or more return values which
 are queued up and copied into the space being pointed at each time the mock is called.
@@ -194,25 +196,36 @@ Callback:
 
 If all those other options don't work, and you really need to do something custom, you
 still have a choice. As soon as you stub a callback in a test, it will call the callback
-whenever the mock is encountered and return the retval returned from the callback (if any)
-instead of performing the usual expect checks. It can be configured to check the arguments 
-first (like expects) or just jump directly to the callback.
+whenever the mock is encountered and return the retval returned from the callback (if any).
 
-* `void func(void)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+* `void func(void)` => `void func_[AddCallback,Stub](CMOCK_func_CALLBACK callback)`
 where `CMOCK_func_CALLBACK` looks like: `void func(int NumCalls)`
-* `void func(params)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+* `void func(params)` => `void func_[AddCallback,Stub](CMOCK_func_CALLBACK callback)`
 where `CMOCK_func_CALLBACK` looks like: `void func(params, int NumCalls)`
-* `retval func(void)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+* `retval func(void)` => `void func_[AddCallback,Stub](CMOCK_func_CALLBACK callback)`
 where `CMOCK_func_CALLBACK` looks like: `retval func(int NumCalls)`
-* `retval func(params)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+* `retval func(params)` => `void func_[AddCallback,Stub](CMOCK_func_CALLBACK callback)`
 where `CMOCK_func_CALLBACK` looks like: `retval func(params, int NumCalls)`
 
+You can choose from two options:
+
+* `func_AddCallback` tells the mock to check its arguments and calling
+order (based on any Expects you've set up) before calling the callback.
+* `func_Stub` tells the mock to skip all the normal checks and jump directly
+to the callback instead. In this case, you are replacing the normal mock calls
+with your own custom stub function.
+
+There is also an older name, `func_StubWithCallback`, which is just an alias
+for either `func_AddCallback` or `func_Stub` depending on setting of the
+`:callback_after_arg_check` toggle. This is deprecated and we recommend using
+the two options above.
+
 
 Cexception:
 -----------
 
-Finally, if you are using Cexception for error handling, you can use this to throw errors 
-from inside mocks. Like Expects, it remembers which call was supposed to throw the error, 
+Finally, if you are using Cexception for error handling, you can use this to throw errors
+from inside mocks. Like Expects, it remembers which call was supposed to throw the error,
 and it still checks parameters first.
 
 * `void func(void)` => `void func_ExpectAndThrow(value_to_throw)`
@@ -295,8 +308,8 @@ from the defaults. We've tried to specify what the defaults are below.
   These are attributes that CMock should ignore for you for testing
   purposes. Custom compiler extensions and externs are handy things to
   put here. If your compiler is choking on some extended syntax, this
-  is often a good place to look. 
-  
+  is often a good place to look.
+
   * defaults: ['__ramfunc', '__irq', '__fiq', 'register', 'extern']
   * **note:** this option will reinsert these attributes onto the mock's calls.
     If that isn't what you are looking for, check out :strippables.
@@ -306,16 +319,16 @@ from the defaults. We've tried to specify what the defaults are below.
   might show up in your codebase. If it encounters something it doesn't
   recognize, it's not going to mock it. We have the most common covered,
   but there are many compilers out there, and therefore many other options.
-  
+
   * defaults: ['__stdcall', '__cdecl', '__fastcall']
   * **note:** this option will reinsert these attributes onto the mock's calls.
     If that isn't what you are looking for, check out :strippables.
 
 * `:callback_after_arg_check`:
   Tell `:callback` plugin to do the normal argument checking **before** it
-  calls the callback function by setting this to true. WHen false, the
+  calls the callback function by setting this to true. When false, the
   callback function is called **instead** of the argument verification.
-  
+
   * default: false
 
 * `:callback_include_count`:
@@ -323,14 +336,14 @@ from the defaults. We've tried to specify what the defaults are below.
   number of times the callback has been called. If set to false, the
   callback has the same interface as the mocked function. This can be
   handy when you're wanting to use callback as a stub.
-  
+
   * default: true
 
 * `:cexception_include`:
   Tell `:cexception` plugin where to find CException.h... You only need to
   define this if it's not in your build path already... which it usually
   will be for the purpose of your builds.
-  
+
   * default: *nil*
 
 * `:enforce_strict_ordering`:
@@ -339,14 +352,14 @@ from the defaults. We've tried to specify what the defaults are below.
   will verify that the sizes are in the order you specified. You might
   *also* want to make sure that all different functions are called in a
   particular order. If so, set this to true.
-  
+
   * default: false
 
 * `:framework`:
   Currently the only option is `:unity.` Eventually if we support other
   unity test frameworks (or if you write one for us), they'll get added
   here.
-  
+
   : default: :unity
 
 * `:includes`:
@@ -354,11 +367,11 @@ from the defaults. We've tried to specify what the defaults are below.
   mocks. Useful for global types and definitions used in your project.
   There are more specific versions if you care WHERE in the mock files
   the includes get placed. You can define any or all of these options.
-  
+
   * `:includes`
   * `:includes_h_pre_orig_header`
   * `:includes_h_post_orig_header`
-  * `:includes_c_pre_header` 
+  * `:includes_c_pre_header`
   * `:includes_c_post_header`
   * default: nil #for all 5 options
 
@@ -368,60 +381,60 @@ from the defaults. We've tried to specify what the defaults are below.
   the time (though it tries its best). If it comes across a type it doesn't
   recognize, you have a choice on how you want it to handle it. It can either
   perform a raw memory comparison and report any differences, or it can fail
-  with a meaningful message. Either way, this feature will only happen after 
+  with a meaningful message. Either way, this feature will only happen after
   all other mechanisms have failed (The thing encountered isn't a standard
   type. It isn't in the :treat_as list. It isn't in a custom unity_helper).
 
   * default: true
-  
+
 * `:mock_path`:
   The directory where you would like the mock files generated to be
   placed.
-  
+
   * default: mocks
 
 * `:mock_prefix`:
   The prefix to prepend to your mock files. For example, if it's “Mock”, a file
   “USART.h” will get a mock called “MockUSART.c”. This CAN be used with a suffix
   at the same time.
-  
+
   * default: Mock
 
 * `:mock_suffix`:
   The suffix to append to your mock files. For example, it it's "_Mock", a file
   "USART.h" will get a mock called "USART_Mock.h". This CAN be used with a prefix
   at the same time.
-  
+
   * default: ""
 
 * `:plugins`:
   An array of which plugins to enable. ':expect' is always active. Also
   available currently:
-  
-  * `:ignore` 
-  * `:ignore_arg` 
+
+  * `:ignore`
+  * `:ignore_arg`
   * `:expect_any_args`
   * `:array`
-  * `:cexception` 
-  * `:callback` 
+  * `:cexception`
+  * `:callback`
   * `:return_thru_ptr`
 
 * `:strippables`:
   An array containing a list of items to remove from the header
   before deciding what should be mocked. This can be something simple
   like a compiler extension CMock wouldn't recognize, or could be a
-  regex to reject certain function name patterns. This is a great way to 
+  regex to reject certain function name patterns. This is a great way to
   get rid of compiler extensions when your test compiler doesn't support
   them. For example, use `:strippables: ['(?:functionName\s*\(+.*?\)+)']`
   to prevent a function `functionName` from being mocked. By default, it
   is ignoring all gcc attribute extensions.
-  
+
   * default: ['(?:__attribute__\s*\(+.*?\)+)']
-  
+
 * `:subdir`:
-  This is a relative subdirectory for your mocks.  Set this to e.g. "sys" in 
+  This is a relative subdirectory for your mocks.  Set this to e.g. "sys" in
   order to create a mock for `sys/types.h` in `(:mock_path)/sys/`.
-  
+
   * default: ""
 
 * `:treat_as`:
@@ -432,11 +445,11 @@ from the defaults. We've tried to specify what the defaults are below.
   did that one for you). Maybe you have a type that is a pointer to an
   array of unsigned characters? No problem, just add 'UINT8_T*' =>
   'HEX8*'
-  
-  * NOTE: unlike the other options, your specifications MERGE with the 
+
+  * NOTE: unlike the other options, your specifications MERGE with the
     default list. Therefore, if you want to override something, you must
     reassign it to something else (or to *nil* if you don't want it)
-    
+
   * default:
     * 'int': 'INT'
     * 'char': 'INT8'
@@ -479,18 +492,30 @@ from the defaults. We've tried to specify what the defaults are below.
     * 'float': 'FLOAT'
     * 'double': 'FLOAT'
 
+* `:treat_as_array`:
+  A specialized sort of `:treat_as` to be used when you've created a
+  typedef of an array type, such as `typedef int TenIntegers[10];`.  This
+  is a hash of typedef name to element type.  For example:
+
+        { "TenIntegers" => "int",
+          "ArrayOfFloat" => "float" }
+
+  Telling CMock about these typedefs allows it to be more intelligent
+  about parameters of such types, so that you can use features like
+  ExpectWithArray and ReturnArrayThruPtr with them.
+
 * `:treat_as_void`:
   We've seen "fun" legacy systems typedef 'void' with a custom type,
   like MY_VOID. Add any instances of those to this list to help CMock
   understand how to deal with your code.
-  
+
   * default: []
 
 * `:treat_externs`:
   This specifies how you want CMock to handle functions that have been
   marked as extern in the header file. Should it mock them?
-  
-  * `:include` will mock externed functions 
+
+  * `:include` will mock externed functions
   * `:exclude` will ignore externed functions (default).
 
 * `:unity_helper_path`:
@@ -500,23 +525,23 @@ from the defaults. We've tried to specify what the defaults are below.
   trick is that you make sure you follow the naming convention:
   `UNITY_TEST_ASSERT_EQUAL_YourType`. If it finds macros of the right
   shape that match that pattern, it'll use them.
-  
+
   * default: []
 
 * `:verbosity`:
-  How loud shoudl CMock be?
-  
+  How loud should CMock be?
+
   * 0 for errors only
   * 1 for errors and warnings
-  * 2 for normal (default) 
+  * 2 for normal (default)
   * 3 for verbose
 
 * `:weak`:
-  When set this to some value, the generated mocks are defined as weak 
+  When set this to some value, the generated mocks are defined as weak
   symbols using the configured format. This allows them to be overridden
-  in particular tests. 
-  
-  * Set to '__attribute ((weak))' for weak mocks when using GCC. 
+  in particular tests.
+
+  * Set to '__attribute ((weak))' for weak mocks when using GCC.
   * Set to any non-empty string for weak mocks when using IAR.
   * default: ""
 
@@ -525,7 +550,7 @@ from the defaults. We've tried to specify what the defaults are below.
   it, it usually contains function prototypes (otherwise what was the
   point?). You can control what happens when this isn't true. You can
   set this to `:warn,` `:ignore,` or `:error`
-  
+
   * default: :warn
 
 * `:when_ptr`:
@@ -538,15 +563,77 @@ from the defaults. We've tried to specify what the defaults are below.
   single element of what is being pointed to. So if you have a pointer
   to a struct called ORGAN_T, it will compare one ORGAN_T (whatever that
   is).
-  
+
   * default: :smart
 
+* `:array_size_type`:
+* `:array_size_name`:
+  When the `:array` plugin is disabled, these options do nothing.
+
+  When the `:array` plugin is enabled, these options allow CMock to recognize
+  functions with parameters that might refer to an array, like the following,
+  and treat them more intelligently:
+
+  * `void GoBananas(Banana * bananas, int num_bananas)`
+  * `int write_data(int fd, const uint8_t * data, uint32_t size)`
+
+  To recognize functions like these, CMock looks for a parameter list
+  containing a pointer (which could be an array) followed by something that
+  could be an array size.  "Something", by default, means an `int` or `size_t`
+  parameter with a name containing "size" or "len".
+
+  `:array_size_type` is a list of additional types (besides `int` and `size_t`)
+  that could be used for an array size parameter.  For example, to get CMock to
+  recognize that `uint32_t size` is an array size, you'd need to say:
+
+        cfg[:array_size_type] = ['uint32_t']
+
+  `:array_size_name` is a regular expression used to match an array size
+  parameter by name.  By default, it's 'size|len'.  To get CMock to recognize a
+  name like `num_bananas`, you could tell it to also accept names containing
+  'num_' like this:
+
+        cfg[:array_size_name] = 'size|len|num_'
+
+  Parameters must match *both* `:array_size_type` and `:array_size_name` (and
+  must come right after a pointer parameter) to be treated as an array size.
+
+  Once you've told it how to recognize your arrays, CMock will give you _Expect
+  calls that work more like _ExpectWithArray, and compare an array of objects
+  rather than just a single object.
+
+  For example, if you write the following, CMock will check that GoBananas is
+  called and passed an array containing a green banana followed by a yellow
+  banana:
+
+        Banana b[2] = {GreenBanana, YellowBanana};
+        GoBananas_Expect(b, 2);
+
+  In other words, `GoBananas_Expect(b, 2)` now works just the same as:
+
+        GoBananas_ExpectWithArray(b, 2, 2);
+
+* `:fail_on_unexpected_calls`:
+  By default, CMock will fail a test if a mock is called without _Expect and _Ignore
+  called first. While this forces test writers to be more explicit in their expectations,
+  it can clutter tests with _Expect or _Ignore calls for functions which are not the focus
+  of the test. While this is a good indicator that this module should be refactored, some
+  users are not fans of the additional noise.
+
+  Therefore, :fail_on_unexpected_calls can be set to false to force all mocks to start with
+  the assumption that they are operating as _Ignore unless otherwise specified.
+
+  * default: true
+  * **note:**
+    If this option is disabled, the mocked functions will return
+    a default value (0) when called (and only if they have to return something of course).
+
 
 Compiled Options:
 -----------------
 
 A number of #defines also exist for customizing the cmock experience.
-Feel free to pass these into your compiler or whatever is most 
+Feel free to pass these into your compiler or whatever is most
 convenient. CMock will otherwise do its best to guess what you want
 based on other settings, particularly Unity's settings.
 
@@ -559,7 +646,7 @@ based on other settings, particularly Unity's settings.
 * `CMOCK_MEM_SIZE`
   In static mode this is the total amount of memory you are allocating
   to Cmock. In Dynamic mode this is the size of each chunk allocated
-  at once (larger numbers grab more memory but require less mallocs).
+  at once (larger numbers grab more memory but require fewer mallocs).
 
 * `CMOCK_MEM_ALIGN`
   The way to align your data to. Not everything is as flexible as
@@ -577,12 +664,26 @@ based on other settings, particularly Unity's settings.
   This needs to be something big enough to point anywhere in Cmock's
   memory space... usually it's an unsigned int.
 
+Other Tips
+==========
+
+resetTest
+---------
+
+While this isn't strictly a CMock feature, often users of CMock are using
+either the test runner generator scripts in Unity or using Ceedling. In
+either case, there is a handy function called `resetTest` which gets
+generated with your runner. You can then use this handy function in your tests
+themselves. Call it during a test to have CMock validate everything to this point
+and start over clean. This is really useful when wanting to test a function in
+an iterative manner with different arguments.
+
 Examples
 ========
 
-You can look in the examples directory for a couple of examples on how 
+You can look in the [examples directory](/examples/) for a couple of examples on how
 you might tool CMock into your build process. You may also want to consider
-using [Ceedling](https://throwtheswitch.org/Ceedling). Please note that
-these examples are meant to show how the build process works. They have 
+using [Ceedling](https://throwtheswitch.org/ceedling). Please note that
+these examples are meant to show how the build process works. They have
 failing tests ON PURPOSE to show what that would look like. Don't be alarmed. ;)
 

examples/make_example/Makefile

@@ -1,8 +1,8 @@
 CC ?= gcc
-BUILD_DIR ?= ./build
-SRC_DIR ?= ./src
-TEST_DIR ?= ./test
-TEST_BUILD_DIR ?= ${BUILD_DIR}/test
+export BUILD_DIR ?= ./build
+export SRC_DIR ?= ./src
+export TEST_DIR ?= ./test
+export TEST_BUILD_DIR ?= ${BUILD_DIR}/test
 TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport
 OBJ ?= ${BUILD_DIR}/obj
 OBJ_DIR = ${OBJ}

examples/temp_sensor/rakefile_helper.rb

@@ -151,7 +151,7 @@ module RakefileHelpers
     report command_string
     output = `#{command_string}`.chomp
     report(output) if (verbose && !output.nil? && (output.length > 0))
-    unless $?.exitstatus.zero? || ok_to_fail
+    unless (!$?.nil? && $?.exitstatus.zero?) || ok_to_fail
       raise "Command failed. (Returned #{$?.exitstatus})"
     end
     return output
@@ -185,7 +185,7 @@ module RakefileHelpers
       obj_list = []
 
       # Detect dependencies and build required required modules
-      header_list = extract_headers(test) + ['cmock.h']
+      header_list = (extract_headers(test) + ['cmock.h'] + [ $cfg[:cmock][:unity_helper_path] ]).compact.uniq
       header_list.each do |header|
 
         #create mocks if needed

lib/cmock_config.rb

@@ -19,8 +19,10 @@ class CMockConfig
     :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
@@ -35,6 +37,8 @@ class CMockConfig
     :includes_c_pre_header       => nil,
     :includes_c_post_header      => nil,
     :orig_header_include_fmt     => "#include \"%s\"",
+    :array_size_type             => [],
+    :array_size_name             => 'size|len',
   }
 
   def initialize(options=nil)
@@ -60,6 +64,7 @@ class CMockConfig
     end
     options[:unity_helper_path] ||= options[:unity_helper]
     options[:unity_helper_path] = [options[:unity_helper_path]] if options[:unity_helper_path].is_a? String
+    options[:includes_c_post_header] = ((options[:includes_c_post_header] || []) + (options[:unity_helper_path] || [])).uniq
     options[:plugins].compact!
     options[:plugins].map! {|p| p.to_sym}
     @options = options
@@ -68,7 +73,11 @@ class CMockConfig
     treat_as_map.merge!(@options[:treat_as])
     @options[:treat_as] = treat_as_map
 
-    @options.each_key { |key| eval("def #{key.to_s}() return @options[:#{key.to_s}] end") }
+    @options.each_key do |key|
+      unless methods.include?(key)
+        eval("def #{key.to_s}() return @options[:#{key.to_s}] end")
+      end
+    end
   end
 
   def load_config_file_from_yaml yaml_filename
@@ -119,6 +128,8 @@ class CMockConfig
       'UINT32'          => 'HEX32',
       'UINT32_T'        => 'HEX32',
       'void*'           => 'HEX8_ARRAY',
+      'void const*'     => 'HEX8_ARRAY',
+      'const void*'     => 'HEX8_ARRAY',
       'unsigned short'  => 'HEX16',
       'uint16'          => 'HEX16',
       'uint16_t'        => 'HEX16',
@@ -130,6 +141,8 @@ class CMockConfig
       'UINT8'           => 'HEX8',
       'UINT8_T'         => 'HEX8',
       'char*'           => 'STRING',
+      'char const*'     => 'STRING',
+      'const char*'     => 'STRING',
       'pCHAR'           => 'STRING',
       'cstring'         => 'STRING',
       'CSTRING'         => 'STRING',

lib/cmock_generator.rb

@@ -18,6 +18,7 @@ class CMockGenerator
     @weak        = @config.weak
     @ordered     = @config.enforce_strict_ordering
     @framework   = @config.framework.to_s
+    @fail_on_unexpected_calls = @config.fail_on_unexpected_calls
 
     @subdir      = @config.subdir
 
@@ -56,9 +57,7 @@ class CMockGenerator
   private if $ThisIsOnlyATest.nil? ##############################
 
   def create_mock_subdir()
-    if @subdir
-      @file_writer.create_subdir(@subdir)
-    end
+    @file_writer.create_subdir(@subdir)
   end
 
   def create_mock_header_file(parsed_stuff)
@@ -94,6 +93,7 @@ class CMockGenerator
     file << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
     file << "#ifndef _#{define_name}_H\n"
     file << "#define _#{define_name}_H\n\n"
+    file << "#include \"#{@framework}.h\"\n"
     @includes_h_pre_orig_header.each {|inc| file << "#include #{inc}\n"}
     file << @config.orig_header_include_fmt.gsub(/%s/, "#{orig_filename}") + "\n"
     @includes_h_post_orig_header.each {|inc| file << "#include #{inc}\n"}
@@ -102,6 +102,9 @@ class CMockGenerator
     file << "\n"
     file << "/* Ignore the following warnings, since we are copying code */\n"
     file << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    file << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
+    file << "#pragma GCC diagnostic push\n"
+    file << "#endif\n"
     file << "#if !defined(__clang__)\n"
     file << "#pragma GCC diagnostic ignored \"-Wpragmas\"\n"
     file << "#endif\n"
@@ -124,7 +127,14 @@ class CMockGenerator
   end
 
   def create_mock_header_footer(header)
-    header << "\n#endif\n"
+    header << "\n"
+    header << "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n"
+    header << "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n"
+    header << "#pragma GCC diagnostic pop\n"
+    header << "#endif\n"
+    header << "#endif\n"
+    header << "\n"
+    header << "#endif\n"
   end
 
   def create_source_header_section(file, filename, functions)
@@ -133,7 +143,6 @@ class CMockGenerator
     file << "#include <string.h>\n"
     file << "#include <stdlib.h>\n"
     file << "#include <setjmp.h>\n"
-    file << "#include \"#{@framework}.h\"\n"
     file << "#include \"cmock.h\"\n"
     @includes_c_pre_header.each {|inc| file << "#include #{inc}\n"}
     file << "#include \"#{header_file}\"\n"
@@ -179,9 +188,15 @@ class CMockGenerator
 
   def create_mock_verify_function(file, functions)
     file << "void #{@clean_mock_name}_Verify(void)\n{\n"
-    verifications = functions.collect {|function| @plugins.run(:mock_verify, function)}.join
-    file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n" unless verifications.empty?
-    file << verifications
+    verifications = functions.collect do |function|
+      v = @plugins.run(:mock_verify, function)
+      v.empty? ? v : ["  call_instance = Mock.#{function[:name]}_CallInstance;\n", v]
+    end.join
+    unless verifications.empty?
+      file << "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n"
+      file << "  CMOCK_MEM_INDEX_TYPE call_instance;\n"
+      file << verifications
+    end
     file << "}\n\n"
   end
 
@@ -196,6 +211,11 @@ class CMockGenerator
     file << "  CMock_Guts_MemFreeAll();\n"
     file << "  memset(&Mock, 0, sizeof(Mock));\n"
     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
+    end
+
     if (@ordered)
       file << "  GlobalExpectCount = 0;\n"
       file << "  GlobalVerifyOrder = 0;\n"
@@ -235,10 +255,9 @@ class CMockGenerator
       file << "  if (cmock_call_instance->CallOrder < GlobalVerifyOrder)\n"
       file << "    UNITY_TEST_FAIL(cmock_line, CMockStringCalledLate);\n"
     end
-    return_type = function[:return][:const?] ? "(const #{function[:return][:type]})" : ((function[:return][:type] =~ /cmock/) ? "(#{function[:return][:type]})" : '')
     file << @plugins.run(:mock_implementation, function)
     file << "  UNITY_CLR_DETAILS();\n"
-    file << "  return #{return_type}cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?])
+    file << "  return cmock_call_instance->ReturnVal;\n" unless (function[:return][:void?])
     file << "}\n\n"
   end
 

lib/cmock_generator_plugin_array.rb

@@ -27,8 +27,8 @@ class CMockGeneratorPluginArray
     return nil unless function[:contains_ptr?]
     args_call   = function[:args].map{|m| m[:ptr?] ? "#{m[:name]}, #{m[:name]}_Depth" : "#{m[:name]}"}.join(', ')
     args_string = function[:args].map do |m|
-      const_str = m[:const?] ? 'const ' : ''
-      m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+      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" +
@@ -44,8 +44,8 @@ class CMockGeneratorPluginArray
     lines = []
     func_name = function[:name]
     args_string = function[:args].map do |m|
-      const_str = m[:const?] ? 'const ' : ''
-      m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+      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?])

lib/cmock_generator_plugin_callback.rb

@@ -16,85 +16,73 @@ class CMockGeneratorPluginCallback
     @priority = 6
 
     @include_count = @config.callback_include_count
-    if (@config.callback_after_arg_check)
-      alias :mock_implementation          :mock_implementation_for_callbacks_after_arg_check
-      alias :mock_implementation_precheck :nothing
-    else
-      alias :mock_implementation_precheck :mock_implementation_for_callbacks_without_arg_check
-      alias :mock_implementation          :nothing
-    end
   end
 
   def instance_structure(function)
     func_name = function[:name]
-    "  CMOCK_#{func_name}_CALLBACK #{func_name}_CallbackFunctionPointer;\n" +
+    "  int #{func_name}_CallbackBool;\n" \
+    "  CMOCK_#{func_name}_CALLBACK #{func_name}_CallbackFunctionPointer;\n" \
     "  int #{func_name}_CallbackCalls;\n"
   end
 
   def mock_function_declarations(function)
     func_name = function[:name]
-    return_type = function[:return][:const?] ? "const #{function[:return][:type]}" : function[:return][:type]
+    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" ]
-    "typedef #{return_type} (* CMOCK_#{func_name}_CALLBACK)(#{styles[style]});\nvoid #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback);\n"
+    "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" \
+    "#define #{func_name}_StubWithCallback #{func_name}_#{action}\n"
   end
 
-  def mock_implementation_for_callbacks_after_arg_check(function)
-    func_name   = function[:name]
-    return_cast = function[:return][:const?] ? "(#{function[:return][:type]})" : ""
-    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
-    case(style)
-      when 0 then "    Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 4 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 5 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 6 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 7 then "    cmock_call_instance->ReturnVal = #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
-    end
+  def generate_call(function)
+    args = function[:args].map { |m| m[:name] }
+    args << "Mock.#{function[:name]}_CallbackCalls++" if @include_count
+    "Mock.#{function[:name]}_CallbackFunctionPointer(#{args.join(', ')})"
   end
 
-  def mock_implementation_for_callbacks_without_arg_check(function)
-    func_name   = function[:name]
-    return_cast = function[:return][:const?] ? "(#{function[:return][:type]})" : ""
-    style  = (@include_count ? 1 : 0) | (function[:args].empty? ? 0 : 2) | (function[:return][:void?] ? 0 : 4)
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n  {\n" +
-    case(style)
-      when 0 then "    Mock.#{func_name}_CallbackFunctionPointer();\n    return;\n  }\n"
-      when 1 then "    Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
-      when 2 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n    return;\n  }\n"
-      when 3 then "    Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n    return;\n  }\n"
-      when 4 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer();\n  }\n"
-      when 5 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(Mock.#{func_name}_CallbackCalls++);\n  }\n"
-      when 6 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')});\n  }\n"
-      when 7 then "    return #{return_cast}Mock.#{func_name}_CallbackFunctionPointer(#{function[:args].map{|m| m[:name]}.join(', ')}, Mock.#{func_name}_CallbackCalls++);\n  }\n"
-    end
+  def mock_implementation(function)
+    "  if (Mock.#{function[:name]}_CallbackFunctionPointer != NULL)\n  {\n" +
+      if function[:return][:void?]
+        "    #{generate_call(function)};\n  }\n"
+      else
+        "    cmock_call_instance->ReturnVal = #{generate_call(function)};\n  }\n"
+      end
   end
 
-  def nothing(function)
-    return ""
+  def mock_implementation_precheck(function)
+    "  if (!Mock.#{function[:name]}_CallbackBool &&\n" \
+    "      Mock.#{function[:name]}_CallbackFunctionPointer != NULL)\n  {\n" +
+      if function[:return][:void?]
+        "    #{generate_call(function)};\n" \
+        "    UNITY_CLR_DETAILS();\n" \
+        "    return;\n  }\n"
+      else
+        "    #{function[:return][:type]} ret = #{generate_call(function)};\n" \
+        "    UNITY_CLR_DETAILS();\n" \
+        "    return ret;\n  }\n"
+      end
   end
 
   def mock_interfaces(function)
     func_name = function[:name]
+    has_ignore = @config.plugins.include? :ignore
     lines = ""
-    lines << "void #{func_name}_StubWithCallback(CMOCK_#{func_name}_CALLBACK Callback)\n{\n"
-    if @config.plugins.include? :ignore
-      lines << "  Mock.#{func_name}_IgnoreBool = (int)0;\n"
-    end
+    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"
+    lines << "  Mock.#{func_name}_CallbackFunctionPointer = Callback;\n}\n\n"
+    lines << "void #{func_name}_Stub(CMOCK_#{func_name}_CALLBACK Callback)\n{\n"
+    lines << "  Mock.#{func_name}_IgnoreBool = (int)0;\n" if has_ignore
+    lines << "  Mock.#{func_name}_CallbackBool = (int)0;\n"
     lines << "  Mock.#{func_name}_CallbackFunctionPointer = Callback;\n}\n\n"
-  end
-
-  def mock_destroy(function)
-    "  Mock.#{function[:name]}_CallbackFunctionPointer = NULL;\n" +
-    "  Mock.#{function[:name]}_CallbackCalls = 0;\n"
   end
 
   def mock_verify(function)
     func_name = function[:name]
-    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
+    "  if (Mock.#{func_name}_CallbackFunctionPointer != NULL)\n    call_instance = CMOCK_GUTS_NONE;\n"
   end
 
 end

lib/cmock_generator_plugin_cexception.rb

@@ -41,7 +41,6 @@ class CMockGeneratorPluginCexception
 
   def mock_interfaces(function)
     arg_insert = (function[:args_string] == "void") ? "" : "#{function[:args_string]}, "
-    call_string = function[:args].map{|m| m[:name]}.join(', ')
     [ "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),

lib/cmock_generator_plugin_expect.rb

@@ -64,11 +64,11 @@ class CMockGeneratorPluginExpect
 
   def mock_implementation_might_check_args(function)
     return "" if (function[:args].empty?)
-    lines = "  if (cmock_call_instance->IgnoreMode != CMOCK_ARG_NONE)\n  {\n"
+    lines = "  if (!cmock_call_instance->ExpectAnyArgsBool)\n  {\n"
     function[:args].each do |arg|
       lines << @utils.code_verify_an_arg_expectation(function, arg)
     end
-    lines << "\n  }\n"
+    lines << "  }\n"
     lines
   end
 
@@ -91,14 +91,13 @@ class CMockGeneratorPluginExpect
     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 << "  UNITY_CLR_DETAILS();\n"
     lines << "}\n\n"
   end
 
   def mock_verify(function)
-    func_name = function[:name]
     "  UNITY_SET_DETAIL(CMockString_#{function[:name]});\n" +
-    "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.#{func_name}_CallInstance, cmock_line, CMockStringCalledLess);\n"
+    "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == call_instance, cmock_line, CMockStringCalledLess);\n" +
+    "  UNITY_CLR_DETAILS();\n"
   end
 
 end

lib/cmock_generator_plugin_expect_any_args.rb

@@ -15,54 +15,39 @@ class CMockGeneratorPluginExpectAnyArgs
     @priority = 3
   end
 
-  def instance_structure(function)
-    if (function[:return][:void?]) || (@config.plugins.include? :ignore)
-      ""
-    else
-      "  #{function[:return][:type]} #{function[:name]}_FinalReturn;\n"
-    end
-  end
-
   def instance_typedefs(function)
-    "  CMOCK_ARG_MODE IgnoreMode;\n"
+    "  int ExpectAnyArgsBool;\n"
   end
 
   def mock_function_declarations(function)
-
-    if (function[:return][:void?])
-      return "#define #{function[:name]}_ExpectAnyArgs() #{function[:name]}_CMockExpectAnyArgs(__LINE__)\n" +
-             "void #{function[:name]}_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line);\n"
+    unless (function[:args].empty?)
+      if (function[:return][:void?])
+        return "#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" +
+               "void #{function[:name]}_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, #{function[:return][:str]});\n"
+      end
     else
-      return "#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
   end
 
-  # def mock_implementation(function)
-  #   lines = "  if (cmock_call_instance->IgnoreMode == CMOCK_ARG_NONE)\n  {\n"
-  #   if (function[:return][:void?])
-  #     lines << "    return;\n  }\n"
-  #   else
-  #     retval = function[:return].merge( { :name => "cmock_call_instance->ReturnVal"} )
-  #     lines << "  " + @utils.code_assign_argument_quickly("Mock.#{function[:name]}_FinalReturn", retval) unless (retval[:void?])
-  #     return_type = function[:return][:const?] ? "(const #{function[:return][:type]})" : ((function[:return][:type] =~ /cmock/) ? "(#{function[:return][:type]})" : '')
-  #     lines << "    return #{return_type}cmock_call_instance->ReturnVal;\n  }\n"
-  #   end
-  #   lines
-  # end
-
   def mock_interfaces(function)
     lines = ""
-    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"
+    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 << @utils.code_add_base_expectation(function[:name], true)
+      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
-    lines << @utils.code_add_base_expectation(function[:name], true)
-    unless (function[:return][:void?])
-      lines << "  cmock_call_instance->ReturnVal = cmock_to_return;\n"
-    end
-    lines << "  cmock_call_instance->IgnoreMode = CMOCK_ARG_NONE;\n"
-    lines << "}\n\n"
+    return lines
   end
 end

lib/cmock_generator_plugin_ignore.rb

@@ -40,10 +40,9 @@ class CMockGeneratorPluginIgnore
       lines << "    return;\n  }\n"
     else
       retval = function[:return].merge( { :name => "cmock_call_instance->ReturnVal"} )
-      return_type = function[:return][:const?] ? "(const #{function[:return][:type]})" : ((function[:return][:type] =~ /cmock/) ? "(#{function[:return][:type]})" : '')
-      lines << "    if (cmock_call_instance == NULL)\n      return #{return_type}Mock.#{function[:name]}_FinalReturn;\n"
+      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 << "    return #{return_type}cmock_call_instance->ReturnVal;\n  }\n"
+      lines << "    return cmock_call_instance->ReturnVal;\n  }\n"
     end
     lines
   end
@@ -65,8 +64,12 @@ class CMockGeneratorPluginIgnore
     lines << "}\n\n"
   end
 
+  def mock_ignore(function)
+    "  Mock.#{function[:name]}_IgnoreBool = (int) 1;\n"
+  end
+
   def mock_verify(function)
     func_name = function[:name]
-    "  if (Mock.#{func_name}_IgnoreBool)\n    Mock.#{func_name}_CallInstance = CMOCK_GUTS_NONE;\n"
+    "  if (Mock.#{func_name}_IgnoreBool)\n    call_instance = CMOCK_GUTS_NONE;\n"
   end
 end

lib/cmock_generator_plugin_ignore_arg.rb

@@ -29,14 +29,12 @@ class CMockGeneratorPluginIgnoreArg
     lines = []
     func_name = function[:name]
     function[:args].each do |arg|
-      arg_name = arg[:name]
-      arg_type = arg[:type]
-      lines << "void #{function[:name]}_CMockIgnoreArg_#{arg[:name]}(UNITY_LINE_TYPE cmock_line)\n"
+      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 << "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);\n"
-      lines << "  cmock_call_instance->IgnoreArg_#{arg_name} = 1;\n"
+      lines << "  cmock_call_instance->IgnoreArg_#{arg[:name]} = 1;\n"
       lines << "}\n\n"
     end
     lines

lib/cmock_generator_plugin_return_thru_ptr.rb

@@ -24,7 +24,13 @@ class CMockGeneratorPluginReturnThruPtr
     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]})"
-        lines << " #{function[:name]}_CMockReturnMemThruPtr_#{arg[:name]}(__LINE__, #{arg[:name]}, sizeof(*#{arg[:name]}))\n"
+        # 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)"
@@ -40,7 +46,6 @@ class CMockGeneratorPluginReturnThruPtr
     func_name = function[:name]
     function[:args].each do |arg|
       arg_name = arg[:name]
-      arg_type = arg[:type]
       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"
@@ -60,7 +65,6 @@ class CMockGeneratorPluginReturnThruPtr
     lines = []
     function[:args].each do |arg|
       arg_name = arg[:name]
-      arg_type = arg[:type]
       if (@utils.ptr_or_str?(arg[:type]) and not arg[:const?])
         lines << "  if (cmock_call_instance->ReturnThruPtr_#{arg_name}_Used)\n"
         lines << "  {\n"

lib/cmock_generator_utils.rb

@@ -19,7 +19,20 @@ class CMockGeneratorUtils
     @ignore_arg   = @config.plugins.include? :ignore_arg
     @ignore       = @config.plugins.include? :ignore
     @treat_as     = @config.treat_as
-	  @helpers = helpers
+    @helpers = helpers
+  end
+
+  def self.arg_type_with_const(arg)
+    # Restore any "const" that was removed in header parsing
+    if arg[:type].include?('*')
+      arg[:const_ptr?] ? "#{arg[:type]} const" : arg[:type]
+    else
+      arg[:const?] ? "const #{arg[:type]}" : arg[:type]
+    end
+  end
+
+  def arg_type_with_const(arg)
+    self.class.arg_type_with_const(arg)
   end
 
   def code_verify_an_arg_expectation(function, arg)
@@ -44,7 +57,7 @@ class CMockGeneratorUtils
     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->IgnoreMode = CMOCK_ARG_ALL;\n" if (@expect_any)
+    lines << "  cmock_call_instance->ExpectAnyArgsBool = (int)0;\n" if (@expect_any)
     lines
   end
 
@@ -58,9 +71,12 @@ class CMockGeneratorUtils
 
   def code_assign_argument_quickly(dest, arg)
     if (arg[:ptr?] or @treat_as.include?(arg[:type]))
-      "  #{dest} = #{arg[:const?] ? "(#{arg[:type]})" : ''}#{arg[:name]};\n"
+      "  #{dest} = #{arg[:name]};\n"
     else
-      "  memcpy(&#{dest}, &#{arg[:name]}, sizeof(#{arg[:type]}));\n"
+      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"
     end
   end
 
@@ -68,13 +84,15 @@ class CMockGeneratorUtils
     if (function[:args_string] != "void")
       if (@arrays)
         args_string = function[:args].map do |m|
-          const_str = m[ :const? ] ? 'const ' : ''
-          m[:ptr?] ? "#{const_str}#{m[:type]} #{m[:name]}, int #{m[:name]}_Depth" : "#{const_str}#{m[:type]} #{m[:name]}"
+          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"
       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"
@@ -87,7 +105,13 @@ class CMockGeneratorUtils
   def code_call_argument_loader(function)
     if (function[:args_string] != "void")
       args = function[:args].map do |m|
-        (@arrays and m[:ptr?]) ? "#{m[:name]}, 1" : m[:name]
+        if (@arrays and m[:ptr?] and not m[:array_data?])
+          "#{m[:name]}, 1"
+        elsif (@arrays and m[:array_size?])
+          "#{m[:name]}, #{m[:name]}"
+        else
+          m[:name]
+        end
       end
       "  CMockExpectParameters_#{function[:name]}(cmock_call_instance, #{args.join(', ')});\n"
     else
@@ -112,12 +136,11 @@ class CMockGeneratorUtils
                  else
                    (@helpers.nil? or @helpers[:unity_helper].nil?) ? ["UNITY_TEST_ASSERT_EQUAL",''] : @helpers[:unity_helper].get_helper(c_type)
                  end
-    unity_msg  = "Function '#{function[:name]}' called with unexpected value for argument '#{arg_name}'."
-    return c_type, arg_name, expected, ignore, unity_func[0], unity_func[1], unity_msg
+    return 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, unity_msg = lookup_expect_type(function, arg)
+    c_type, arg_name, expected, ignore, unity_func, pre = lookup_expect_type(function, arg)
     lines = ""
     lines << "  if (!#{ignore})\n" if @ignore_arg
     lines << "  {\n"
@@ -152,12 +175,13 @@ class CMockGeneratorUtils
   end
 
   def code_verify_an_arg_expectation_with_normal_arrays(function, arg)
-    c_type, arg_name, expected, ignore, unity_func, pre, unity_msg = lookup_expect_type(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 = ""
     lines << "  if (!#{ignore})\n" if @ignore_arg
     lines << "  {\n"
     lines << "    UNITY_SET_DETAILS(CMockString_#{function[:name]},CMockString_#{arg_name});\n"
+    lines << "    if (#{pre}#{expected} != #{pre}#{arg_name}) {\n"
     case(unity_func)
       when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
         c_type_local = c_type.gsub(/\*$/,'')
@@ -183,17 +207,18 @@ class CMockGeneratorUtils
       else
         lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n"
     end
-    lines << "  }\n"
+    lines << "      }\n  }\n"
     lines
   end
 
   def code_verify_an_arg_expectation_with_smart_arrays(function, arg)
-    c_type, arg_name, expected, ignore, unity_func, pre, unity_msg = lookup_expect_type(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 = ""
     lines << "  if (!#{ignore})\n" if @ignore_arg
     lines << "  {\n"
     lines << "    UNITY_SET_DETAILS(CMockString_#{function[:name]},CMockString_#{arg_name});\n"
+    lines << "    if (#{pre}#{expected} != #{pre}#{arg_name}) {\n"
     case(unity_func)
       when "UNITY_TEST_ASSERT_EQUAL_MEMORY"
         c_type_local = c_type.gsub(/\*$/,'')
@@ -221,7 +246,7 @@ class CMockGeneratorUtils
       else
         lines << "    #{unity_func}(#{pre}#{expected}, #{pre}#{arg_name}, cmock_line, CMockStringMismatch);\n"
     end
-    lines << "  }\n"
+    lines << "    }\n  }\n"
     lines
   end
 

lib/cmock_header_parser.rb

@@ -6,16 +6,20 @@
 
 class CMockHeaderParser
 
-  attr_accessor :funcs, :c_attributes, :treat_as_void, :treat_externs
+  attr_accessor :funcs, :c_attr_noconst, :c_attributes, :treat_as_void, :treat_externs
 
   def initialize(cfg)
     @funcs = []
     @c_strippables = cfg.strippables
-    @c_attributes = (['const'] + cfg.attributes).uniq
+    @c_attr_noconst = cfg.attributes.uniq - ['const']
+    @c_attributes = ['const'] + c_attr_noconst
     @c_calling_conventions = cfg.c_calling_conventions.uniq
+    @treat_as_array = cfg.treat_as_array
     @treat_as_void = (['void'] + cfg.treat_as_void).uniq
-    @declaration_parse_matcher = /([\d\w\s\*\(\),\[\]]+??)\(([\d\w\s\*\(\),\.\[\]+-]*)\)$/m
+    @declaration_parse_matcher = /([\w\s\*\(\),\[\]]+??)\(([\w\s\*\(\),\.\[\]+-]*)\)$/m
     @standards = (['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
     @when_no_prototypes = cfg.when_no_prototypes
     @local_as_void = @treat_as_void
     @verbosity = cfg.verbosity
@@ -53,7 +57,7 @@ class CMockHeaderParser
     # void must be void for cmock _ExpectAndReturn calls to process properly, not some weird typedef which equates to void
     # to a certain extent, this action assumes we're chewing on pre-processed header files, otherwise we'll most likely just get stuff from @treat_as_void
     @local_as_void = @treat_as_void
-    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+([\w\d]+)\s*;/)
+    void_types = source.scan(/typedef\s+(?:\(\s*)?void(?:\s*\))?\s+([\w]+)\s*;/)
     if void_types
       @local_as_void += void_types.flatten.uniq.compact
     end
@@ -62,9 +66,9 @@ class CMockHeaderParser
     source.gsub!(/\s*\\\s*/m, ' ')
 
     #remove comments (block and line, in three steps to ensure correct precedence)
-    source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
-    source.gsub!(/\/\*.*?\*\//m, '')                     # remove block comments
-    source.gsub!(/\/\/.*$/, '')                          # remove line comments (all that remain)
+    source.gsub!(/(?<!\*)\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '')  # remove line comments that comment out the start of blocks
+    source.gsub!(/\/\*.*?\*\//m, '')                            # remove block comments
+    source.gsub!(/\/\/.*$/, '')                                 # remove line comments (all that remain)
 
     # remove assembler pragma sections
     source.gsub!(/^\s*#\s*pragma\s+asm\s+.*?#\s*pragma\s+endasm/m, '')
@@ -79,13 +83,16 @@ class CMockHeaderParser
     # enums, unions, structs, and typedefs can all contain things (e.g. function pointers) that parse like function prototypes, so yank them
     # forward declared structs are removed before struct definitions so they don't mess up real thing later. we leave structs keywords in function prototypes
     source.gsub!(/^[\w\s]*struct[^;\{\}\(\)]+;/m, '')                                      # remove forward declared structs
-    source.gsub!(/^[\w\s]*(enum|union|struct|typepdef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '') # remove struct, union, and enum definitions and typedefs with braces
+    source.gsub!(/^[\w\s]*(enum|union|struct|typedef)[\w\s]*\{[^\}]+\}[\w\s\*\,]*;/m, '')  # remove struct, union, and enum definitions and typedefs with braces
     source.gsub!(/(\W)(?:register|auto|static|restrict)(\W)/, '\1\2')                      # remove problem keywords
     source.gsub!(/\s*=\s*['"a-zA-Z0-9_\.]+\s*/, '')                                        # remove default value statements from argument lists
     source.gsub!(/^(?:[\w\s]*\W)?typedef\W[^;]*/m, '')                                     # remove typedef statements
     source.gsub!(/\)(\w)/, ') \1')                                                         # add space between parenthese and alphanumeric
     source.gsub!(/(^|\W+)(?:#{@c_strippables.join('|')})(?=$|\W+)/,'\1') unless @c_strippables.empty? # remove known attributes slated to be stripped
 
+    #scan standalone function pointers and remove them, because they can just be ignored
+    source.gsub!(/\w+\s*\(\s*\*\s*\w+\s*\)\s*\([^)]*\)\s*;/,';')
+
     #scan for functions which return function pointers, because they are a pain
     source.gsub!(/([\w\s\*]+)\(*\(\s*\*([\w\s\*]+)\s*\(([\w\s\*,]*)\)\)\s*\(([\w\s\*,]*)\)\)*/) do |m|
       functype = "cmock_#{@module_name}_func_ptr#{@typedefs.size + 1}"
@@ -94,7 +101,14 @@ class CMockHeaderParser
     end
 
     # remove nested pairs of braces because no function declarations will be inside of them (leave outer pair for function definition detection)
-    source.gsub!(/\{([^\{\}]*|\g<0>)*\}/m, '{ }')
+    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
 
     # remove function definitions by stripping off the arguments right now
     source.gsub!(/\([^\)]*\)\s*\{[^\}]*\}/m, ";")
@@ -132,51 +146,98 @@ class CMockHeaderParser
     return funcs
   end
 
+  def parse_type_and_name(arg)
+    # Split up words and remove known attributes.  For pointer types, make sure
+    # to remove 'const' only when it applies to the pointer itself, not when it
+    # applies to the type pointed to.  For non-pointer types, remove any
+    # occurrence of 'const'.
+    arg.gsub!(/(\w)\*/,'\1 *') # pull asterisks away from preceding word
+    arg.gsub!(/\*(\w)/,'* \1') # pull asterisks away from following word
+    arg_array = arg.split
+    arg_info = divine_ptr_and_const(arg)
+    arg_info[:name] = arg_array[-1]
+
+    attributes = arg.include?('*') ? @c_attr_noconst : @c_attributes
+    attr_array = []
+    type_array = []
+
+    arg_array[0..-2].each do |word|
+      if attributes.include?(word)
+        attr_array << word
+      elsif @c_calling_conventions.include?(word)
+        arg_info[:c_calling_convention] = word
+      else
+        type_array << word
+      end
+    end
+
+    if arg_info[:const_ptr?]
+      attr_array << 'const'
+      type_array.delete_at(type_array.rindex('const'))
+    end
+
+    arg_info[:modifier] = attr_array.join(' ')
+    arg_info[:type] = type_array.join(' ').gsub(/\s+\*/,'*') # remove space before asterisks
+    return arg_info
+  end
+
   def parse_args(arg_list)
     args = []
     arg_list.split(',').each do |arg|
       arg.strip!
       return args if (arg =~ /^\s*((\.\.\.)|(void))\s*$/)   # we're done if we reach void by itself or ...
-      arg_array = arg.split
-      arg_elements = arg_array - @c_attributes              # split up words and remove known attributes
-      args << { :type   => (arg_type = arg_elements[0..-2].join(' ')),
-                :name   => arg_elements[-1]
-              }.merge(divine_ptr_and_const(arg))
+
+      arg_info = parse_type_and_name(arg)
+      arg_info.delete(:modifier)             # don't care about this
+      arg_info.delete(:c_calling_convention) # don't care about this
+
+      # in C, array arguments implicitly degrade to pointers
+      # make the translation explicit here to simplify later logic
+      if @treat_as_array[arg_info[:type]] and not arg_info[:ptr?] then
+        arg_info[:type] = "#{@treat_as_array[arg_info[:type]]}*"
+        arg_info[:type] = "const #{arg_info[:type]}" if arg_info[:const?]
+        arg_info[:ptr?] = true
+      end
+
+      args << arg_info
     end
+
+    # Try to find array pair in parameters following this pattern : <type> * <name>, <@array_size_type> <@array_size_name>
+    args.each_with_index {|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
+    }
+
     return args
   end
 
-  def divine_ptr(arg_type)
-    return false unless arg_type.include? '*'
-    return false if arg_type.gsub(/(const|char|\*|\s)+/,'').empty?
+  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
   end
 
   def divine_const(arg)
-    return false if !(/(?:^|\s|\*)const(?:\*|\s|$)/ =~ arg)   # check for const as part of a larger word
-    return true  if (/const(?:\w|\s)*\*/ =~ arg)              # check const comes before * indicating const data
-    return false if (/\*\s*const/ =~ arg)                     # check const comes after * indicating const ptr
-    return true
+    # 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
   end
 
   def divine_ptr_and_const(arg)
-    divination = { :ptr? => false, :const? => false, :const_ptr? => false }
+    divination = {}
 
-    #first check if there is a pointer present and that it's not part of a C string or function definition
-    #divination[:ptr?] = (arg.split[0..-2].join.include?('*') && !arg.gsub(/(const|char|\*|\s)+/,'').empty?)
-    divination[:ptr?] = (arg.include?('*') && !arg.gsub(/(const|char|\*|\s)+/,'').empty?)
+    divination[:ptr?] = divine_ptr(arg)
+    divination[:const?] = divine_const(arg)
 
-    #if there isn't a const that isn't part of a larger word, we're done
-    return divination if !(/(?:^|\s|\*)const(?:\*|\s|$)/ =~ arg)
-    divination[:const?] = true
-
-    # check const comes after * indicating const ptr
-    if (/\*\s*const/ =~ arg)
-      divination[:const_ptr?] = true
-
-      #check const comes before * indicating also const data
-      divination[:const?] = (/const(?:\w|\s)*\*/ =~ arg) ? true : false
-    end
+    # an arg containing "const" after the last * is a constant pointer
+    divination[:const_ptr?] = (/\*(?!.*\*)\s*const(\s|$)/ =~ arg) ? true : false
 
     return divination
   end
@@ -186,7 +247,7 @@ class CMockHeaderParser
       return 'void'
     else
       c=0
-      arg_list.gsub!(/(\w+)(?:\s*\[\s*\(*[\s\d\w+-]*\)*\s*\])+/,'*\1')  # magically turn brackets into asterisks, also match for parentheses that come from macros
+      arg_list.gsub!(/(\w+)(?:\s*\[\s*\(*[\s\w+-]*\)*\s*\])+/,'*\1')  # magically turn brackets into asterisks, also match for parentheses that come from macros
       arg_list.gsub!(/\s+\*/,'*')                                       # remove space to place asterisks with type (where they belong)
       arg_list.gsub!(/\*(\w)/,'* \1')                                   # pull asterisks away from arg to place asterisks with type (where they belong)
 
@@ -229,35 +290,24 @@ class CMockHeaderParser
     args = regex_match[2].strip
 
     #process function attributes, return type, and name
-    descriptors = regex_match[1]
-    descriptors.gsub!(/\s+\*/,'*')     #remove space to place asterisks with return type (where they belong)
-    descriptors.gsub!(/\*(\w)/,'* \1') #pull asterisks away from function name to place asterisks with return type (where they belong)
-    descriptors = descriptors.split    #array of all descriptor strings
+    parsed = parse_type_and_name(regex_match[1])
 
-    #grab name
-    decl[:name] = descriptors[-1]      #snag name as last array item
-
-    #build attribute and return type strings
-    decl[:modifier] = []
-    rettype = []
-    full_retval = descriptors[0..-2].join(' ')
-    descriptors[0..-2].each do |word|
-      if @c_attributes.include?(word)
-        decl[:modifier] << word
-      elsif @c_calling_conventions.include?(word)
-        decl[:c_calling_convention] = word
-      else
-        rettype << word
-      end
+    decl[:name] = parsed[:name]
+    decl[:modifier] = parsed[:modifier]
+    unless parsed[:c_calling_convention].nil?
+      decl[:c_calling_convention] = parsed[:c_calling_convention]
     end
-    decl[:modifier] = decl[:modifier].join(' ')
-    rettype = rettype.join(' ')
+
+    rettype = parsed[:type]
     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')
-                    }.merge(divine_ptr_and_const(full_retval))
+    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?]
+                    }
 
     #remove default argument statements from mock definitions
     args.gsub!(/=\s*[a-zA-Z0-9_\.]+\s*/, ' ')

lib/cmock_plugin_manager.rb

@@ -2,30 +2,25 @@
 #   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]
-# ========================================== 
+# ==========================================
+
+require 'thread'
 
 class CMockPluginManager
 
   attr_accessor :plugins
-  
+
   def initialize(config, utils)
     @plugins = []
     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)
-      begin
-        unless (Object.const_defined? object_name)
-          require "#{File.expand_path(File.dirname(__FILE__))}/cmock_generator_plugin_#{plugin_name.downcase}.rb"
-        end
-        @plugins << eval("#{object_name}.new(config, utils)")
-      rescue
-        raise "ERROR: CMock unable to load plugin '#{plugin_name}'"
-      end
+      self.class.plugin_require_mutex.synchronize { load_plugin(plugin_name, object_name, config, utils) }
     end
     @plugins.sort! {|a,b| a.priority <=> b.priority }
   end
-  
+
   def run(method, args=nil)
     if args.nil?
       return @plugins.collect{ |plugin| plugin.send(method) if plugin.respond_to?(method) }.flatten.join
@@ -33,8 +28,28 @@ class CMockPluginManager
       return @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 }
   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}"
+    end
+  end
 end

meson.build

@@ -0,0 +1,72 @@
+###################################################################################
+#                                                                                 #
+# NAME: meson.build                                                               #
+#                                                                                 #
+# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams.                         #
+# WRITTEN BY: Michael Brockus.                                                    #
+#                                                                                 #
+# License: MIT                                                                    #
+#                                                                                 #
+###################################################################################
+
+
+project('cmock', 'c',
+    license         : 'MIT',
+    meson_version   : '>=0.52.0',
+    subproject_dir : 'vendor',
+    default_options: [
+        'buildtype=minsize',
+        'optimization=3', 
+        'warning_level=3',
+        'werror=true',
+        ]
+)
+lang = 'c'
+cc = meson.get_compiler(lang)
+
+
+##
+#
+# Meson: Add compiler flags
+#
+##
+if cc.get_id() == 'clang'
+    add_project_arguments(cc.get_supported_arguments(
+            [
+            '-Wweak-vtables', '-Wexit-time-destructors',
+            '-Wglobal-constructors', '-Wmissing-noreturn' 
+            ]
+        ), language: lang)
+endif
+
+if cc.get_argument_syntax() == 'gcc'
+    add_project_arguments(cc.get_supported_arguments(
+            [
+            '-Wformat', '-Waddress', '-Winit-self', '-Wno-multichar',
+            '-Wpointer-arith'       , '-Wwrite-strings'              , 
+            '-Wno-parentheses'      , '-Wno-type-limits'             , 
+            '-Wformat-security'     , '-Wunreachable-code'           , 
+            '-Waggregate-return'    , '-Wformat-nonliteral'          ,
+            '-Wmissing-prototypes'  , '-Wold-style-definition'       ,
+            '-Wmissing-declarations', '-Wmissing-include-dirs'       , 
+            '-Wno-unused-parameter' , '-Wdeclaration-after-statement'
+            ]
+        ), language: lang)
+endif
+
+if cc.get_id() == 'msvc'
+    add_project_arguments(cc.get_supported_arguments(
+            [
+            '/w44265', '/w44061', '/w44062', 
+            '/wd4018', '/wd4146', '/wd4244',
+            '/wd4305',
+            ]
+        ), language: lang)
+endif
+
+
+unity_dep = dependency('unity', fallback: ['unity', 'unity_dep'])
+
+subdir('src')
+
+cmock_dep = declare_dependency(link_with: cmock_lib, include_directories: cmock_dir)

release/build.info

@@ -1,2 +0,0 @@
-215
-

release/version.info

@@ -1,2 +0,0 @@
-2.4.4
-

scripts/create_makefile.rb

@@ -18,8 +18,9 @@ RUNNERS_DIR = File.join(TEST_BUILD_DIR, 'runners')
 MOCKS_DIR = File.join(TEST_BUILD_DIR, 'mocks')
 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_MATCHER = /#{MOCK_PREFIX}[A-Za-z_][A-Za-z0-9_\-\.]+#{MOCK_SUFFIX}/
 
 [TEST_BUILD_DIR, OBJ_DIR, RUNNERS_DIR, MOCKS_DIR, TEST_BIN_DIR].each do |dir|
   FileUtils.mkdir_p dir
@@ -33,9 +34,9 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
 
   # Define make variables
   mkfile.puts "CC ?= gcc"
-  mkfile.puts "BUILD_DIR ?= ./build"
-  mkfile.puts "SRC_DIR ?= ./src"
-  mkfile.puts "TEST_DIR ?= ./test"
+  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 "CMOCK_DIR ?= #{CMOCK_DIR}"
   mkfile.puts "UNITY_DIR ?= #{UNITY_DIR}"
@@ -58,8 +59,23 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
   test_sources = Dir["#{TEST_DIR}/**/test_*.c"]
   test_targets = []
   generator = UnityTestRunnerGenerator.new
+
+  # headers that begin with prefix or end with suffix are not included
   all_headers = Dir["#{SRC_DIR}/**/*.h"]
 
+  def reject_mock_files(file)
+    extn = File.extname file
+    filename = File.basename file, extn
+    if MOCK_SUFFIX.empty?
+      return filename.start_with? MOCK_PREFIX
+    end
+    return (filename.start_with? MOCK_PREFIX or filename.end_with? MOCK_SUFFIX)
+  end
+
+  all_headers = all_headers.reject { |f| reject_mock_files(f) }
+
+  makefile_targets = []
+
   test_sources.each do |test|
     module_name = File.basename(test, '.c')
     src_module_name = module_name.sub(/^test_/, '')
@@ -67,14 +83,39 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
     runner_source = File.join(RUNNERS_DIR, "runner_#{module_name}.c")
     runner_obj = File.join(OBJ_DIR, "runner_#{module_name}.o")
     test_bin = File.join(TEST_BIN_DIR, module_name)
-    test_results = File.join(TEST_BIN_DIR, module_name + '.result')
+    test_results = File.join(TEST_BIN_DIR, module_name + '.testresult')
+
+    cfg = {
+      src: test,
+      includes: generator.find_includes(File.readlines(test).join(''))
+    }
 
     # 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")
-    mkfile.puts "#{module_obj}: #{module_src}"
-    mkfile.puts "\t${CC} -o $@ -c $< -DTEST -I #{SRC_DIR}"
-    mkfile.puts ""
+    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 ""
+    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}.c")
+        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
+    end
 
     # Create runners
     mkfile.puts "#{runner_source}: #{test}"
@@ -83,17 +124,14 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
 
     # 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}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{MOCKS_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}"
     mkfile.puts ""
 
     # Collect mocks to generate
-    cfg = {
-      src: test,
-      includes: generator.find_includes(File.readlines(test).join(''))
-    }
     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}
+
     module_names_to_mock = local_mocks.map{|name| "#{name.sub(/#{MOCK_PREFIX}/,'')}.h"}
     headers_to_mock = []
     module_names_to_mock.each do |name|
@@ -107,6 +145,7 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
       raise "Module header '#{name}' not found to mock!" unless header_to_mock
       headers_to_mock << header_to_mock
     end
+
     all_headers_to_mock += headers_to_mock
     mock_objs = headers_to_mock.map do |hdr|
       mock_name = MOCK_PREFIX + File.basename(hdr, '.h')
@@ -116,18 +155,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}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} -I #{MOCKS_DIR} ${INCLUDE_PATH}"
     mkfile.puts ""
 
     # Build test suite executable
-    test_objs = "#{test_obj} #{runner_obj} #{module_obj} #{mock_objs.join(' ')} #{UNITY_OBJ} #{CMOCK_OBJ}"
+    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 $@ #{test_objs}"
+    mkfile.puts "\t${CC} -o $@ ${LDFLAGS} #{test_objs}"
     mkfile.puts ""
 
     # Run test suite and generate report
     mkfile.puts "#{test_results}: #{test_bin}"
-    mkfile.puts "\t-#{test_bin} &> #{test_results}"
+    mkfile.puts "\t-#{test_bin} > #{test_results} 2>&1"
     mkfile.puts ""
 
     test_targets << test_bin
@@ -145,7 +184,7 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
     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}"
+    mkfile.puts "\t${CC} -o $@ -c $< ${TEST_CFLAGS} -I #{MOCKS_DIR} -I #{SRC_DIR} -I #{UNITY_SRC} -I #{CMOCK_SRC} ${INCLUDE_PATH}"
     mkfile.puts ""
   end
 
@@ -157,7 +196,7 @@ File.open(TEST_MAKEFILE, "w") do |mkfile|
   mkfile.puts ""
 
   # Create target to run all tests
-  mkfile.puts "test: #{test_targets.map{|t| t + '.result'}.join(' ')} test_summary"
+  mkfile.puts "test: #{test_targets.map{|t| t + '.testresult'}.join(' ')} test_summary"
   mkfile.puts ""
 
 end

scripts/test_summary.rb

@@ -7,7 +7,7 @@ begin
   build_dir = ENV.fetch('BUILD_DIR', './build')
   test_build_dir = ENV.fetch('TEST_BUILD_DIR', File.join(build_dir, 'test'))
 
-  results = Dir["#{test_build_dir}/*.result"]
+  results = Dir["#{test_build_dir}/*.testresult"]
   parser = UnityTestSummary.new
   parser.targets = results
   parser.run

src/cmock.c

@@ -4,13 +4,12 @@
     [Released under MIT License. Please refer to license.txt for details]
 ========================================== */
 
-#include "unity.h"
 #include "cmock.h"
 
 //public constants to be used by mocks
 const char* CMockStringOutOfMemory = "CMock has run out of memory. Please allocate more.";
 const char* CMockStringCalledMore  = "Called more times than expected.";
-const char* CMockStringCalledLess  = "Called less times than expected.";
+const char* CMockStringCalledLess  = "Called fewer times than expected.";
 const char* CMockStringCalledEarly = "Called earlier than expected.";
 const char* CMockStringCalledLate  = "Called later than expected.";
 const char* CMockStringCallOrder   = "Called out of order.";
@@ -24,11 +23,11 @@ const char* CMockStringMismatch    = "Function called with unexpected argument v
 #ifdef CMOCK_MEM_DYNAMIC
 static unsigned char*         CMock_Guts_Buffer = NULL;
 static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #else
 static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
 static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
+static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE;
 #endif
 
 //-------------------------------------------------------
@@ -48,12 +47,17 @@ CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
     size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
   if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
   {
-#ifdef CMOCK_MEM_DYNAMIC
-    CMock_Guts_BufferSize += CMOCK_MEM_SIZE + size;
-    CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, (size_t)CMock_Guts_BufferSize);
-    if (CMock_Guts_Buffer == NULL)
-#endif //yes that if will continue to the return below if TRUE
-      return CMOCK_GUTS_NONE;
+#ifndef CMOCK_MEM_DYNAMIC
+    return CMOCK_GUTS_NONE; // nothing we can do; our static buffer is out of memory
+#else
+    // our dynamic buffer does not have enough room; request more via realloc()
+    CMOCK_MEM_INDEX_TYPE new_buffersize = CMock_Guts_BufferSize + CMOCK_MEM_SIZE + size;
+    unsigned char* new_buffer = realloc(CMock_Guts_Buffer, (size_t)new_buffersize);
+    if (new_buffer == NULL)
+      return CMOCK_GUTS_NONE; // realloc() failed; out of memory
+    CMock_Guts_Buffer = new_buffer;
+    CMock_Guts_BufferSize = new_buffersize;
+#endif
   }
 
   //determine where we're putting this new block, and init its pointer to be the end of the line
@@ -163,6 +167,14 @@ void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
   }
 }
 
+//-------------------------------------------------------
+// CMock_Guts_MemBytesCapacity
+//-------------------------------------------------------
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void)
+{
+  return (sizeof(CMock_Guts_Buffer) - CMOCK_MEM_ALIGN_SIZE);
+}
+
 //-------------------------------------------------------
 // CMock_Guts_MemBytesFree
 //-------------------------------------------------------

src/cmock.h

@@ -9,6 +9,11 @@
 
 #include "cmock_internals.h"
 
+#define CMOCK_VERSION_MAJOR    2
+#define CMOCK_VERSION_MINOR    5
+#define CMOCK_VERSION_BUILD    0
+#define CMOCK_VERSION          ((CMOCK_VERSION_MAJOR << 16) | (CMOCK_VERSION_MINOR << 8) | CMOCK_VERSION_BUILD)
+
 //should be big enough to index full range of CMOCK_MEM_MAX
 #ifndef CMOCK_MEM_INDEX_TYPE
 #define CMOCK_MEM_INDEX_TYPE  unsigned int
@@ -16,10 +21,6 @@
 
 #define CMOCK_GUTS_NONE   (0)
 
-#define CMOCK_ARG_MODE    CMOCK_MEM_INDEX_TYPE
-#define CMOCK_ARG_ALL     0
-#define CMOCK_ARG_NONE    ((CMOCK_MEM_INDEX_TYPE)(~0U))
-
 //-------------------------------------------------------
 // Memory API
 //-------------------------------------------------------
@@ -30,6 +31,7 @@ CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemEndOfChain(CMOCK_MEM_INDEX_TYPE root_index);
 
 void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
 
+CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesCapacity(void);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesFree(void);
 CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesUsed(void);
 void                  CMock_Guts_MemFreeAll(void);

src/cmock_internals.h

@@ -7,6 +7,8 @@
 #ifndef CMOCK_FRAMEWORK_INTERNALS_H
 #define CMOCK_FRAMEWORK_INTERNALS_H
 
+#include "unity.h"
+
 //These are constants that the generated mocks have access to
 extern const char* CMockStringOutOfMemory;
 extern const char* CMockStringCalledMore;

src/meson.build

@@ -0,0 +1,17 @@
+###################################################################################
+#                                                                                 #
+# NAME: meson.build                                                               #
+#                                                                                 #
+# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams.                         #
+# WRITTEN BY: Michael Brockus.                                                    #
+#                                                                                 #
+# License: MIT                                                                    #
+#                                                                                 #
+###################################################################################
+
+cmock_dir = include_directories('.')
+
+cmock_lib = static_library(meson.project_name(), 
+    sources: ['cmock.c'],
+    dependencies: [unity_dep],
+    include_directories: cmock_dir)

test/c/TestCMockC.c

@@ -25,8 +25,18 @@ void test_MemNewWillReturnNullIfGivenIllegalSizes(void)
   TEST_ASSERT_NULL( CMock_Guts_GetAddressFor(CMOCK_GUTS_NONE) );
 
   //verify we're cleared still
-  TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed());
-  TEST_ASSERT_EQUAL(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesCapacity());
+  TEST_ASSERT_EQUAL_UINT32(0, CMock_Guts_MemBytesUsed());
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesFree());
+}
+
+void test_MemShouldProtectAgainstMemoryOverflow(void)
+{
+  (void)CMock_Guts_MemNew(CMOCK_MEM_SIZE - TEST_MEM_INDEX_SIZE);
+
+  //verify we've used all the memory
+  TEST_ASSERT_LESS_OR_EQUAL_UINT32(TEST_MEM_INDEX_SIZE, CMock_Guts_MemBytesFree());
+  TEST_ASSERT_GREATER_OR_EQUAL_UINT32(CMOCK_MEM_SIZE, CMock_Guts_MemBytesUsed());
 }
 
 void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void)
@@ -258,11 +268,11 @@ void test_ThatWeCanAskForAllSortsOfSizes(void)
   }
 
   //show that we can't ask for too much memory
-  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(12));
-  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(5));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum + 8));
+  TEST_ASSERT_EQUAL_HEX(CMOCK_GUTS_NONE, CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum + 1));
 
   //but we CAN ask for something that will still fit
-  next = CMock_Guts_MemNew(4);
+  next = CMock_Guts_MemNew(CMOCK_MEM_SIZE - sum - 4);
   TEST_ASSERT_MESSAGE(next != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE");
 
   first = CMock_Guts_MemChain(first, next);

test/c/TestCMockC.yml

@@ -8,6 +8,7 @@
   - 'TEST'
   - 'CMOCK_MEM_STATIC'
   - 'CMOCK_MEM_SIZE=128'
+  #- 'CMOCK_MEM_SIZE=40000'
   - 'CMOCK_MEM_ALIGN=2'
   - 'CMOCK_MEM_INDEX_TYPE=int'
 

test/c/TestCMockC_Runner.c

@@ -12,6 +12,7 @@ extern void setUp(void);
 extern void tearDown(void);
 
 extern void test_MemNewWillReturnNullIfGivenIllegalSizes(void);
+extern void test_MemShouldProtectAgainstMemoryOverflow(void);
 extern void test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation(void);
 extern void test_MemNextWillReturnNullIfGivenABadRoot(void);
 extern void test_ThatWeCanClaimAndChainAFewElementsTogether(void);
@@ -26,13 +27,14 @@ int main(void)
   UnityBegin(Unity.TestFile);
 
   RUN_TEST(test_MemNewWillReturnNullIfGivenIllegalSizes, 21);
-  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 32);
-  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 46);
-  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 57);
-  RUN_TEST(test_MemEndOfChain, 282);
-  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 139);
-  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 185);
-  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 233);
+  RUN_TEST(test_MemShouldProtectAgainstMemoryOverflow, 33);
+  RUN_TEST(test_MemChainWillReturnNullAndDoNothingIfGivenIllegalInformation, 42);
+  RUN_TEST(test_MemNextWillReturnNullIfGivenABadRoot, 56);
+  RUN_TEST(test_ThatWeCanClaimAndChainAFewElementsTogether, 67);
+  RUN_TEST(test_MemEndOfChain, 149);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenItRunsOutOfMemory, 195);
+  RUN_TEST(test_ThatCMockStopsReturningMoreDataWhenAskForMoreThanItHasLeftEvenIfNotAtExactEnd, 244);
+  RUN_TEST(test_ThatWeCanAskForAllSortsOfSizes, 298);
 
   UnityEnd();
   return 0;

test/rakefile_helper.rb

@@ -50,6 +50,7 @@ module RakefileHelpers
         includes << m[1]
       end
     end
+    includes << File.basename(filename,".c").slice(5,256) + "_unity_helper.h"
     return includes
   end
 

test/system/systest_generator.rb

@@ -104,7 +104,6 @@ class SystemTestGenerator
     return if tests.nil?
 
     includes = [UNITY_H, CMOCK_H]
-    includes << (namix + UNITY_HELPER_H) if not yaml_hash[:systest][:unity_helper].nil?
     includes << [MOCK_PREFIX + namix + MOCKABLE_H]
     includes << [name + H_EXTENSION]
 

test/system/test_compilation/parsing.h

@@ -50,3 +50,40 @@ extern unsigned long int incredible_descriptors(register const unsigned short a)
 int32_t example_c99_type(int32_t param1);
 
 void I2CIntRegister(uint32_t ui32Base, void (*pfnHandler)(void));
+
+/* these are function pointers, not function declarations USING a function pointer, and so should NOT get mocked */
+int (* func_pointer)(void);
+extern int (*another_func_pointer)(unsigned int argument);
+struct struct_to_be_ignored {
+  union {
+    int i32;
+    void *p;
+  } variant;
+  void (*a_function_pointer_in_a_struct)(void *);
+};
+
+typedef struct
+{
+  uint32_t a;
+  struct
+  {
+    uint32_t bb;
+    float bc;
+    float bd;
+  } b;
+  int (*another_function_pointer_in_a_struct) (void);
+} another_thing_that_should_get_ignored;
+
+inline int stuff(int num)
+{
+    int reg = 0x12;
+    if (num > 0)
+    {
+      reg |= (0x0Eu);
+    }
+    else
+    {
+      reg |= (0x07u);
+    }
+    return reg;
+}

test/system/test_interactions/enforce_strict_ordering.yml

@@ -100,7 +100,7 @@
 
     - :pass: FALSE
       :should: 'fail because bar() is called twice but is expected once'
-      :verify_error: 'Called less times than expected'
+      :verify_error: 'Called fewer times than expected'
       :code: |
         test()
         {

test/system/test_interactions/expect_and_return_custom_types.yml

@@ -3,6 +3,7 @@
   :plugins:
   - # none
   :memcmp_if_unknown: false
+  :unity_helper_path: expect_and_return_custom_types_unity_helper.h
 
 :systest:
   :types: |
@@ -35,7 +36,6 @@
 
   :tests:
     :common: |
-      #include "expect_and_return_custom_types_unity_helper.h"
       void setUp(void) {}
       void tearDown(void) {}
 

test/system/test_interactions/expect_any_args.yml

@@ -66,7 +66,7 @@
         }
 
     - :pass: FALSE
-      :should: 'ignore foo() call details and notice if we called foo() less times than expected'
+      :should: 'ignore foo() call details and notice if we called foo() fewer times than expected'
       :code: |
         test()
         {

test/system/test_interactions/function_pointer_handling.yml

@@ -15,11 +15,11 @@
     void takes_const_function_ptr( unsigned int (* const)(int, char) );
     unsigned short (*returns_function_ptr( const char op_code ))( int, long int );
 
-  :source: 
+  :source:
     :header: |
       void exercise_function_pointer_param(void);
       unsigned short (*exercise_function_pointer_return( const char op_code ))( int, long int );
-      
+
       // functions for function pointer tests
       unsigned int dummy_function1(int a, char b);
       unsigned short dummy_function2(int a, long int b);
@@ -28,7 +28,7 @@
       /*
        * functions used in tests
        */
-       
+
       unsigned int dummy_function1(int a, char b)
       {
         // prevent compiler warnings by using everything

test/system/test_interactions/ignore_and_return.yml

@@ -159,4 +159,171 @@
           TEST_ASSERT_EQUAL(110, function(0, 8, 9));
         }
 
+    - :pass: FALSE
+      :should: 'With "fail_on_unexpected_calls" enabled, Expect/Ignore/... of bar is required and test fails.'
+      :code: |
+        test()
+        {
+          function(1, 2, 3);
+        }
+
+    - :pass: TRUE
+      :should: 'we can override an ignore with an expect and pass'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'we can override an ignore with an expect and fail'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+
+          bar_Expect(2);
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(9);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+
+    - :pass: TRUE
+      :should: 'we can override an ignore and return with an expect and pass'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+          foo_IgnoreAndReturn(30);
+          TEST_ASSERT_EQUAL(90, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(8);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'we can override an ignore and return with an expect and fail'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+          foo_IgnoreAndReturn(0);
+          TEST_ASSERT_EQUAL(0, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_ExpectAndReturn(6, 10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Expect(9);
+          foo_ExpectAndReturn(7, 70);
+          foo_ExpectAndReturn(8, 20);
+          foo_ExpectAndReturn(9, 20);
+          TEST_ASSERT_EQUAL(110, function(7, 8, 9));
+        }
+
+    - :pass: TRUE
+      :should: 'we can override an an expect with an ignore'
+      :code: |
+        test()
+        {
+          bar_Expect(5);
+          bar_Ignore();
+          foo_ExpectAndReturn(1, 50);
+          foo_ExpectAndReturn(2, 60);
+          foo_ExpectAndReturn(3, 70);
+          TEST_ASSERT_EQUAL(180, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'we can override an expect with an ignore and return and pass'
+      :code: |
+        test()
+        {
+          bar_Ignore();
+          foo_IgnoreAndReturn(0);
+          TEST_ASSERT_EQUAL(0, function(1, 2, 3));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 80);
+          foo_IgnoreAndReturn(10);
+          TEST_ASSERT_EQUAL(120, function(4, 5, 6));
+
+          bar_Ignore();
+          foo_IgnoreAndReturn(60);
+          TEST_ASSERT_EQUAL(180, function(7, 8, 9));
+        }
+
+    - :pass: FALSE
+      :should: 'we can override an expect with an ignore and return and fail after'
+      :code: |
+        test()
+        {
+          bar_Expect(5);
+          foo_ExpectAndReturn(4, 30);
+          foo_ExpectAndReturn(5, 50);
+          foo_IgnoreAndReturn(20);
+          TEST_ASSERT_EQUAL(100, function(4, 5, 6));
+
+          bar_Expect(5);
+          foo_ExpectAndReturn(9, 30); //THIS ONE WILL FAIL
+          foo_ExpectAndReturn(2, 80);
+          foo_ExpectAndReturn(3, 60);
+          TEST_ASSERT_EQUAL(170, function(1, 2, 3));
+        }
+
+    - :pass: TRUE
+      :should: 'we can override an expect with an ignore and return and the expected values are ignored'
+      :code: |
+        test()
+        {
+          bar_Expect(5);
+          foo_ExpectAndReturn(2, 30); //NOTE THIS WOULD NORMALLY FAIL
+          foo_ExpectAndReturn(5, 50);
+          foo_IgnoreAndReturn(20);    //BUT WE SAID WE NO LONGER CARE
+          TEST_ASSERT_EQUAL(100, function(4, 5, 6));
+        }
+
 ...

test/system/test_interactions/ignore_strict_mock_calling.yml

@@ -0,0 +1,37 @@
+---
+:cmock:
+  :plugins:
+  - 'ignore'
+  :fail_on_unexpected_calls: FALSE
+
+:systest:
+  :types: |
+
+  :mockable: |
+    int foo(int a);
+    void bar(int b);
+
+  :source:
+    :header: |
+      int function(int a, int b, int c);
+    :code: |
+      int function(int a, int b, int c)
+      {
+        bar(b);
+        return foo(a) + foo(b) + foo(c);
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+    :units:
+    - :pass: TRUE
+      :should: 'With "fail_on_unexpected_calls" disabled, Expect/Ignore/... of bar is NOT required.'
+      :code: |
+        test()
+        {
+          function(1, 2, 3);
+        }
+
+...

test/system/test_interactions/unity_ignores.yml

@@ -12,7 +12,7 @@
     void bar(void);
 
   :source: 
-    :header: |    
+    :header: |
       UINT32 function_a(int a);
       void function_b(void);
 

test/system/test_interactions/unity_void_pointer_compare.yml

@@ -0,0 +1,91 @@
+---
+#The purpose of this test is to verify we handle void pointers as memory compares
+:cmock:
+  :plugins:
+  - :array
+  :treat_as_array:
+    VOID_PTR: unsigned char
+
+:systest:
+  :types: |
+    #include "unity_internals.h"
+    typedef void* VOID_PTR;
+
+  :mockable: |
+    void* ret_v_ptr(void);
+    void get_v_ptr(void* ptr);
+    void get_v_ptr_typedefed(VOID_PTR ptr);
+
+  :source:
+    :header: |
+      void function_a(void);
+
+    :code: |
+      void function_a(void) {
+        void* stuff = ret_v_ptr();
+        get_v_ptr(stuff);
+        get_v_ptr_typedefed((VOID_PTR)stuff);
+      }
+
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+
+    :units:
+    - :pass: TRUE
+      :should: 'handle passing working expects'
+      :code: |
+        test()
+        {
+          char* a = "Hello";
+          char* b = "Hello";
+          ret_v_ptr_ExpectAndReturn(a);
+          get_v_ptr_Expect(b);
+          get_v_ptr_typedefed_Expect((VOID_PTR)b);
+
+          function_a();
+        }
+
+    - :pass: TRUE
+      :should: 'handle passing array expects'
+      :code: |
+        test()
+        {
+          char* a = "Hello";
+          char* b = "Hello";
+          ret_v_ptr_ExpectAndReturn(a);
+          get_v_ptr_ExpectWithArray(b,5);
+          get_v_ptr_typedefed_ExpectWithArray((VOID_PTR)b,5);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle failing expects'
+      :code: |
+        test()
+        {
+          char* a = "Hello";
+          char* b = "Jello";
+          ret_v_ptr_ExpectAndReturn(a);
+          get_v_ptr_Expect(b);
+          get_v_ptr_typedefed_Expect((VOID_PTR)b);
+
+          function_a();
+        }
+
+    - :pass: FALSE
+      :should: 'handle failing array expects'
+      :code: |
+        test()
+        {
+          char* a = "Hello";
+          char* b = "Hella";
+          ret_v_ptr_ExpectAndReturn(a);
+          get_v_ptr_ExpectWithArray(b,5);
+          get_v_ptr_typedefed_ExpectWithArray((VOID_PTR)b,5);
+
+          function_a();
+        }
+...

test/test_helper.rb

@@ -24,20 +24,21 @@ end
 
 def test_return
   {
-    :int     => {:type => "int",   :name => 'cmock_to_return', :ptr? => false, :const? => false, :void? => false, :str => 'int cmock_to_return'},
-    :int_ptr => {:type => "int*",  :name => 'cmock_to_return', :ptr? => true,  :const? => false, :void? => false, :str => 'int* cmock_to_return'},
-    :void    => {:type => "void",  :name => 'cmock_to_return', :ptr? => false, :const? => false, :void? => true,  :str => 'void cmock_to_return'},
-    :string  => {:type => "char*", :name => 'cmock_to_return', :ptr? => false, :const? => true,  :void? => false, :str => 'const char* cmock_to_return'},
+    :int     => {:type => "int",         :name => 'cmock_to_return', :ptr? => false, :const? => false, :void? => false, :str => 'int cmock_to_return'},
+    :int_ptr => {:type => "int*",        :name => 'cmock_to_return', :ptr? => true,  :const? => false, :void? => false, :str => 'int* cmock_to_return'},
+    :void    => {:type => "void",        :name => 'cmock_to_return', :ptr? => false, :const? => false, :void? => true,  :str => 'void cmock_to_return'},
+    :string  => {:type => "const char*", :name => 'cmock_to_return', :ptr? => false, :const? => true,  :void? => false, :str => 'const char* cmock_to_return'},
   }
 end
 
 def test_arg
   {
-    :int        => {:type => "int",      :name => 'MyInt',       :ptr? => false, :const? => false},
-    :int_ptr    => {:type => "int*",     :name => 'MyIntPtr',    :ptr? => true,  :const? => false},
-    :mytype     => {:type => "MY_TYPE",  :name => 'MyMyType',    :ptr? => false, :const? => true},
-    :mytype_ptr => {:type => "MY_TYPE*", :name => 'MyMyTypePtr', :ptr? => true,  :const? => false},
-    :string     => {:type => "char*",    :name => 'MyStr',       :ptr? => false, :const? => true},
+    :int        => {:type => "int",         :name => 'MyInt',       :ptr? => false, :const? => false, :const_ptr? => false},
+    :int_ptr    => {:type => "int*",        :name => 'MyIntPtr',    :ptr? => true,  :const? => false, :const_ptr? => false},
+    :const_ptr  => {:type => "int*",        :name => 'MyConstPtr',  :ptr? => true,  :const? => false, :const_ptr? => true},
+    :double_ptr => {:type => "int const**", :name => 'MyDoublePtr', :ptr? => true,  :const? => true,  :const_ptr? => false},
+    :mytype     => {:type => "MY_TYPE",     :name => 'MyMyType',    :ptr? => false, :const? => true,  :const_ptr? => false},
+    :mytype_ptr => {:type => "MY_TYPE*",    :name => 'MyMyTypePtr', :ptr? => true,  :const? => false, :const_ptr? => false},
+    :string     => {:type => "const char*", :name => 'MyStr',       :ptr? => false, :const? => true,  :const_ptr? => false},
   }
 end
-

test/unit/cmock_config_test.rb

@@ -14,7 +14,8 @@ describe CMockConfig, "Verify CMockConfig Module" do
   it "use default settings when no parameters are specified" do
     config = CMockConfig.new
     assert_equal(CMockConfig::CMockDefaultOptions[:mock_path],             config.mock_path)
-    assert_equal(CMockConfig::CMockDefaultOptions[:includes],              config.includes)
+    assert_nil(CMockConfig::CMockDefaultOptions[:includes])
+    assert_nil(config.includes)
     assert_equal(CMockConfig::CMockDefaultOptions[:attributes],            config.attributes)
     assert_equal(CMockConfig::CMockDefaultOptions[:plugins],               config.plugins)
     assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs],         config.treat_externs)
@@ -35,7 +36,8 @@ describe CMockConfig, "Verify CMockConfig Module" do
     test_plugins = [:soda, :pizza]
     config = CMockConfig.new("#{File.expand_path(File.dirname(__FILE__))}/cmock_config_test.yml")
     assert_equal(CMockConfig::CMockDefaultOptions[:mock_path],              config.mock_path)
-    assert_equal(CMockConfig::CMockDefaultOptions[:includes],               config.includes)
+    assert_nil(CMockConfig::CMockDefaultOptions[:includes])
+    assert_nil(config.includes)
     assert_equal(test_plugins,                                              config.plugins)
     assert_equal(:include,                                                  config.treat_externs)
   end

test/unit/cmock_generator_main_test.rb

@@ -53,6 +53,7 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :includes_c_pre_header, nil
     @config.expect :includes_c_post_header, nil
     @config.expect :subdir, nil
+    @config.expect :fail_on_unexpected_calls, true
     @cmock_generator = CMockGenerator.new(@config, @file_writer, @utils, @plugins)
     @cmock_generator.module_name = @module_name
     @cmock_generator.mock_name = "Mock#{@module_name}"
@@ -70,6 +71,7 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :includes_c_pre_header, nil
     @config.expect :includes_c_post_header, nil
     @config.expect :subdir, nil
+    @config.expect :fail_on_unexpected_calls, true
     @cmock_generator_strict = CMockGenerator.new(@config, @file_writer, @utils, @plugins)
     @cmock_generator_strict.module_name = @module_name
     @cmock_generator_strict.mock_name = "Mock#{@module_name}"
@@ -85,12 +87,12 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :weak, ""
     orig_filename = "PoutPoutFish.h"
     define_name = "MOCKPOUTPOUTFISH_H"
-    mock_name = "MockPoutPoutFish"
     output = []
     expected = [
       "/* AUTOGENERATED FILE. DO NOT EDIT. */\n",
       "#ifndef _#{define_name}\n",
       "#define _#{define_name}\n\n",
+      "#include \"unity.h\"\n",
       "#include \"ConfigRequiredHeader1.h\"\n",
       "#include \"ConfigRequiredHeader2.h\"\n",
       "#include \"#{orig_filename}\"\n",
@@ -98,6 +100,9 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
       "\n",
       "/* Ignore the following warnings, since we are copying code */\n",
       "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n",
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n",
+      "#pragma GCC diagnostic push\n",
+      "#endif\n",
       "#if !defined(__clang__)\n",
       "#pragma GCC diagnostic ignored \"-Wpragmas\"\n",
       "#endif\n",
@@ -127,6 +132,7 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :includes_c_pre_header, nil
     @config.expect :includes_c_post_header, nil
     @config.expect :subdir, nil
+    @config.expect :fail_on_unexpected_calls, true
     @cmock_generator2 = CMockGenerator.new(@config, @file_writer, @utils, @plugins)
     @cmock_generator2.module_name = "Pout-Pout Fish"
     @cmock_generator2.mock_name = "MockPout-Pout Fish"
@@ -137,12 +143,12 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :weak, ""
     orig_filename = "Pout-Pout Fish.h"
     define_name = "MOCKPOUT_POUT_FISH_H"
-    mock_name = "MockPout_Pout_Fish"
     output = []
     expected = [
       "/* AUTOGENERATED FILE. DO NOT EDIT. */\n",
       "#ifndef _#{define_name}\n",
       "#define _#{define_name}\n\n",
+      "#include \"unity.h\"\n",
       "#include \"ConfigRequiredHeader1.h\"\n",
       "#include \"ConfigRequiredHeader2.h\"\n",
       "#include \"#{orig_filename}\"\n",
@@ -150,6 +156,9 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
       "\n",
       "/* Ignore the following warnings, since we are copying code */\n",
       "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n",
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n",
+      "#pragma GCC diagnostic push\n",
+      "#endif\n",
       "#if !defined(__clang__)\n",
       "#pragma GCC diagnostic ignored \"-Wpragmas\"\n",
       "#endif\n",
@@ -173,18 +182,21 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :weak, ""
     orig_filename = "PoutPoutFish.h"
     define_name = "MOCKPOUTPOUTFISH_H"
-    mock_name = "MockPoutPoutFish"
     output = []
     expected = [
       "/* AUTOGENERATED FILE. DO NOT EDIT. */\n",
       "#ifndef _#{define_name}\n",
       "#define _#{define_name}\n\n",
+      "#include \"unity.h\"\n",
       "#include \"ConfigRequiredHeader1.h\"\n",
       "#include \"ConfigRequiredHeader2.h\"\n",
       "#include \"#{orig_filename}\"\n",
       "\n",
       "/* Ignore the following warnings, since we are copying code */\n",
       "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n",
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n",
+      "#pragma GCC diagnostic push\n",
+      "#endif\n",
       "#if !defined(__clang__)\n",
       "#pragma GCC diagnostic ignored \"-Wpragmas\"\n",
       "#endif\n",
@@ -208,12 +220,12 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     @config.expect :weak, ""
     orig_filename = "PoutPoutFish.h"
     define_name = "MOCKPOUTPOUTFISH_H"
-    mock_name = "MockPoutPoutFish"
     output = []
     expected = [
       "/* AUTOGENERATED FILE. DO NOT EDIT. */\n",
       "#ifndef _#{define_name}\n",
       "#define _#{define_name}\n\n",
+      "#include \"unity.h\"\n",
       "#include \"ConfigRequiredHeader1.h\"\n",
       "#include \"ConfigRequiredHeader2.h\"\n",
       "#include \"#{orig_filename}\"\n",
@@ -221,6 +233,9 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
       "\n",
       "/* Ignore the following warnings, since we are copying code */\n",
       "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n",
+      "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n",
+      "#pragma GCC diagnostic push\n",
+      "#endif\n",
       "#if !defined(__clang__)\n",
       "#pragma GCC diagnostic ignored \"-Wpragmas\"\n",
       "#endif\n",
@@ -272,7 +287,15 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
 
   it "append the proper footer to the header file" do
     output = []
-    expected = ["\n#endif\n"]
+    expected = ["\n",
+                "#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__)\n",
+                "#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0)))\n",
+                "#pragma GCC diagnostic pop\n",
+                "#endif\n",
+                "#endif\n",
+                "\n",
+                "#endif\n"
+                ]
 
     @cmock_generator.create_mock_header_footer(output)
 
@@ -289,7 +312,6 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
                  "#include <string.h>\n",
                  "#include <stdlib.h>\n",
                  "#include <setjmp.h>\n",
-                 "#include \"unity.h\"\n",
                  "#include \"cmock.h\"\n",
                  "#include \"MockPoutPoutFish.h\"\n",
                  "\n",
@@ -390,8 +412,11 @@ describe CMockGenerator, "Verify CMockGenerator Module" do
     output = []
     expected = [ "void MockPoutPoutFish_Verify(void)\n{\n",
                  "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
+                 "  CMOCK_MEM_INDEX_TYPE call_instance;\n",
+                 "  call_instance = Mock.First_CallInstance;\n" +
                  "  Uno_First" +
                  "  Dos_First" +
+                 "  call_instance = Mock.Second_CallInstance;\n" +
                  "  Uno_Second" +
                  "  Dos_Second",
                  "}\n\n"

test/unit/cmock_generator_plugin_array_test.rb

@@ -6,21 +6,29 @@
 
 require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require File.expand_path(File.dirname(__FILE__)) + '/../../lib/cmock_generator_plugin_array'
+require File.expand_path(File.dirname(__FILE__)) + '/../../lib/cmock_generator_utils'
+
+class UtilsStub
+  def helpers
+    {}
+  end
+  def arg_type_with_const(arg)
+    CMockGeneratorUtils.arg_type_with_const(arg)
+  end
+  def code_add_base_expectation(func)
+    "mock_retval_0"
+  end
+end
 
 describe CMockGeneratorPluginArray, "Verify CMockPGeneratorluginArray Module" do
   before do
-    create_mocks :utils
-
     #no strict ordering
     @config = create_stub(
       :when_ptr => :compare_data,
       :enforce_strict_ordering => false,
       :respond_to? => true )
 
-    @utils = create_stub(
-       :helpers => {},
-       :code_add_base_expectation => "mock_retval_0"
-    )
+    @utils = UtilsStub.new
 
     @cmock_generator_plugin_array = CMockGeneratorPluginArray.new(@config, @utils)
   end
@@ -29,8 +37,8 @@ describe CMockGeneratorPluginArray, "Verify CMockPGeneratorluginArray Module" do
   end
 
   it "have set up internal priority" do
-    assert_equal(nil,     @cmock_generator_plugin_array.unity_helper)
-    assert_equal(8,       @cmock_generator_plugin_array.priority)
+    assert_nil(@cmock_generator_plugin_array.unity_helper)
+    assert_equal(8, @cmock_generator_plugin_array.priority)
   end
 
   it "not include any additional include files" do
@@ -88,10 +96,10 @@ describe CMockGeneratorPluginArray, "Verify CMockPGeneratorluginArray Module" do
 
   it "add another mock function declaration for functions of style 'const char* func(const int* tofu)'" do
     function = {:name => "Pine",
-                :args => [{ :type => "int*",
-                           :name => "tofu",
-                           :ptr? => true,
-                           :const? => true,
+                :args => [{ :type   => "const int*",
+                            :name   => "tofu",
+                            :ptr?   => true,
+                            :const? => true,
                          }],
                 :return => test_return[:string],
                 :contains_ptr? => true }

test/unit/cmock_generator_plugin_callback_test.rb

@@ -32,7 +32,8 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
 
   it "add to instance structure" do
     function = {:name => "Oak", :args => [:type => "int*", :name => "blah", :ptr? => true], :return => test_return[:int_ptr]}
-    expected = "  CMOCK_Oak_CALLBACK Oak_CallbackFunctionPointer;\n" +
+    expected = "  int Oak_CallbackBool;\n" +
+               "  CMOCK_Oak_CALLBACK Oak_CallbackFunctionPointer;\n" +
                "  int Oak_CallbackCalls;\n"
     returned = @cmock_generator_plugin_callback.instance_structure(function)
     assert_equal(expected, returned)
@@ -41,7 +42,9 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
   it "add mock function declaration for function without arguments" do
     function = {:name => "Maple", :args_string => "void", :args => [], :return => test_return[:void]}
     expected = [ "typedef void (* CMOCK_Maple_CALLBACK)(int cmock_num_calls);\n",
-                 "void Maple_StubWithCallback(CMOCK_Maple_CALLBACK Callback);\n" ].join
+                 "void Maple_AddCallback(CMOCK_Maple_CALLBACK Callback);\n",
+                 "void Maple_Stub(CMOCK_Maple_CALLBACK Callback);\n",
+                 "#define Maple_StubWithCallback Maple_Stub\n" ].join
     returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
@@ -49,7 +52,9 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
   it "add mock function declaration for function without arguments when count is also turned off" do
     function = {:name => "Maple", :args_string => "void", :args => [], :return => test_return[:void]}
     expected = [ "typedef void (* CMOCK_Maple_CALLBACK)(void);\n",
-                 "void Maple_StubWithCallback(CMOCK_Maple_CALLBACK Callback);\n" ].join
+                 "void Maple_AddCallback(CMOCK_Maple_CALLBACK Callback);\n",
+                 "void Maple_Stub(CMOCK_Maple_CALLBACK Callback);\n",
+                 "#define Maple_StubWithCallback Maple_Stub\n" ].join
     @cmock_generator_plugin_callback.include_count = false
     returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
     assert_equal(expected, returned)
@@ -58,7 +63,9 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
   it "add mock function declaration for function with arguments" do
     function = {:name => "Maple", :args_string => "int* tofu", :args => [1], :return => test_return[:void]}
     expected = [ "typedef void (* CMOCK_Maple_CALLBACK)(int* tofu, int cmock_num_calls);\n",
-                 "void Maple_StubWithCallback(CMOCK_Maple_CALLBACK Callback);\n" ].join
+                 "void Maple_AddCallback(CMOCK_Maple_CALLBACK Callback);\n",
+                 "void Maple_Stub(CMOCK_Maple_CALLBACK Callback);\n",
+                 "#define Maple_StubWithCallback Maple_Stub\n" ].join
     returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
@@ -66,7 +73,9 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
   it "add mock function declaration for function with return values" do
     function = {:name => "Maple", :args_string => "int* tofu", :args => [1], :return => test_return[:string]}
     expected = [ "typedef const char* (* CMOCK_Maple_CALLBACK)(int* tofu, int cmock_num_calls);\n",
-                 "void Maple_StubWithCallback(CMOCK_Maple_CALLBACK Callback);\n" ].join
+                 "void Maple_AddCallback(CMOCK_Maple_CALLBACK Callback);\n",
+                 "void Maple_Stub(CMOCK_Maple_CALLBACK Callback);\n",
+                 "#define Maple_StubWithCallback Maple_Stub\n" ].join
     returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
@@ -74,7 +83,9 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
   it "add mock function declaration for function with return values and count is turned off" do
     function = {:name => "Maple", :args_string => "int* tofu", :args => [1], :return => test_return[:string]}
     expected = [ "typedef const char* (* CMOCK_Maple_CALLBACK)(int* tofu);\n",
-                 "void Maple_StubWithCallback(CMOCK_Maple_CALLBACK Callback);\n" ].join
+                 "void Maple_AddCallback(CMOCK_Maple_CALLBACK Callback);\n",
+                 "void Maple_Stub(CMOCK_Maple_CALLBACK Callback);\n",
+                 "#define Maple_StubWithCallback Maple_Stub\n" ].join
     @cmock_generator_plugin_callback.include_count = false
     returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
     assert_equal(expected, returned)
@@ -87,7 +98,7 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "    Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
@@ -99,7 +110,7 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "  }\n"
                ].join
     @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
@@ -110,7 +121,7 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "    cmock_call_instance->ReturnVal = Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
@@ -125,7 +136,7 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "    Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
@@ -141,7 +152,7 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "  }\n"
                ].join
     @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
@@ -156,31 +167,36 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 "    cmock_call_instance->ReturnVal = Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_after_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation(function)
     assert_equal(expected, returned)
   end
 
   it "add mock function implementation for functions without arg check and of style 'void func(void)' when count turned off" do
     function = {:name => "Apple", :args => [], :args_string => "void", :return => test_return[:void]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
+    expected = ["  if (!Mock.Apple_CallbackBool &&\n",
+                "      Mock.Apple_CallbackFunctionPointer != NULL)\n",
                 "  {\n",
                 "    Mock.Apple_CallbackFunctionPointer();\n",
+                "    UNITY_CLR_DETAILS();\n",
                 "    return;\n",
                 "  }\n"
                ].join
     @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_without_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
 
   it "add mock function implementation for functions without arg check and of style 'int func(void)'" do
     function = {:name => "Apple", :args => [], :args_string => "void", :return => test_return[:int]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
+    expected = ["  if (!Mock.Apple_CallbackBool &&\n",
+                "      Mock.Apple_CallbackFunctionPointer != NULL)\n",
                 "  {\n",
-                "    return Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
+                "    int ret = Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
+                "    UNITY_CLR_DETAILS();\n",
+                "    return ret;\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_without_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
 
@@ -190,13 +206,15 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                   { :type => 'uint8_t', :name => 'flag', :ptr? => false} ],
                 :args_string => "int* steak, uint8_t flag",
                 :return=> test_return[:void]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
+    expected = ["  if (!Mock.Apple_CallbackBool &&\n",
+                "      Mock.Apple_CallbackFunctionPointer != NULL)\n",
                 "  {\n",
                 "    Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
+                "    UNITY_CLR_DETAILS();\n",
                 "    return;\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_without_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
 
@@ -206,14 +224,16 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                   { :type => 'uint8_t', :name => 'flag', :ptr? => false} ],
                 :args_string => "int* steak, uint8_t flag",
                 :return=> test_return[:void]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
+    expected = ["  if (!Mock.Apple_CallbackBool &&\n",
+                "      Mock.Apple_CallbackFunctionPointer != NULL)\n",
                 "  {\n",
                 "    Mock.Apple_CallbackFunctionPointer(steak, flag);\n",
+                "    UNITY_CLR_DETAILS();\n",
                 "    return;\n",
                 "  }\n"
                ].join
     @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_without_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
 
@@ -223,12 +243,15 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                   { :type => 'uint8_t', :name => 'flag', :ptr? => false} ],
                 :args_string => "int* steak, uint8_t flag",
                 :return => test_return[:int]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
+    expected = ["  if (!Mock.Apple_CallbackBool &&\n",
+                "      Mock.Apple_CallbackFunctionPointer != NULL)\n",
                 "  {\n",
-                "    return Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
+                "    int ret = Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
+                "    UNITY_CLR_DETAILS();\n",
+                "    return ret;\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_for_callbacks_without_arg_check(function)
+    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
 
@@ -239,21 +262,20 @@ describe CMockGeneratorPluginCallback, "Verify CMockGeneratorPluginCallback Modu
                 :return => test_return[:int]
                }
 
-    expected = ["void Lemon_StubWithCallback(CMOCK_Lemon_CALLBACK Callback)\n",
+    expected = ["void Lemon_AddCallback(CMOCK_Lemon_CALLBACK Callback)\n",
                 "{\n",
                 "  Mock.Lemon_IgnoreBool = (int)0;\n",
+                "  Mock.Lemon_CallbackBool = (int)1;\n",
+                "  Mock.Lemon_CallbackFunctionPointer = Callback;\n",
+                "}\n\n",
+                "void Lemon_Stub(CMOCK_Lemon_CALLBACK Callback)\n",
+                "{\n",
+                "  Mock.Lemon_IgnoreBool = (int)0;\n",
+                "  Mock.Lemon_CallbackBool = (int)0;\n",
                 "  Mock.Lemon_CallbackFunctionPointer = Callback;\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_callback.mock_interfaces(function)
     assert_equal(expected, returned)
   end
-
-  it "add mock destroy for functions" do
-    function = {:name => "Peach", :args => [], :return => test_return[:void] }
-    expected = "  Mock.Peach_CallbackFunctionPointer = NULL;\n" +
-               "  Mock.Peach_CallbackCalls = 0;\n"
-    returned = @cmock_generator_plugin_callback.mock_destroy(function)
-    assert_equal(expected, returned)
-  end
 end

test/unit/cmock_generator_plugin_expect_a_test.rb

@@ -26,8 +26,8 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
   end
 
   it "have set up internal priority on init" do
-    assert_equal(nil,     @cmock_generator_plugin_expect.unity_helper)
-    assert_equal(5,       @cmock_generator_plugin_expect.priority)
+    assert_nil(@cmock_generator_plugin_expect.unity_helper)
+    assert_equal(5, @cmock_generator_plugin_expect.priority)
   end
 
   it "not include any additional include files" do
@@ -119,7 +119,6 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
                 "{\n",
                 "mock_retval_0 ",
                 "mock_retval_1 ",
-                "  UNITY_CLR_DETAILS();\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -136,7 +135,6 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
                 "mock_retval_0 ",
                 "mock_retval_1 ",
                 "mock_retval_2",
-                "  UNITY_CLR_DETAILS();\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -153,7 +151,6 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
                 "mock_retval_0 ",
                 "mock_retval_1 ",
                 "mock_retval_2",
-                "  UNITY_CLR_DETAILS();\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -168,7 +165,6 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
                 "{\n",
                 "mock_retval_0 ",
                 "mock_retval_1 ",
-                "  UNITY_CLR_DETAILS();\n",
                 "}\n\n"
                ].join
     @cmock_generator_plugin_expect.ordered = true
@@ -179,7 +175,8 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module W
   it "add mock verify lines" do
     function = {:name => "Banana" }
     expected = "  UNITY_SET_DETAIL(CMockString_Banana);\n" +
-               "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.Banana_CallInstance, cmock_line, CMockStringCalledLess);\n"
+               "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == call_instance, cmock_line, CMockStringCalledLess);\n" +
+               "  UNITY_CLR_DETAILS();\n"
     returned = @cmock_generator_plugin_expect.mock_verify(function)
     assert_equal(expected, returned)
   end

test/unit/cmock_generator_plugin_expect_any_args_test.rb

@@ -26,15 +26,22 @@ describe CMockGeneratorPluginExpectAnyArgs, "Verify CMockGeneratorPluginExpectAn
     assert(!@cmock_generator_plugin_expect_any_args.respond_to?(:include_files))
   end
 
+  it "ignore functions without arguments" do
+    function = {:name => "Mold", :args_string => "void", :args => [], :return => test_return[:void]}
+    expected = ""
+    returned = @cmock_generator_plugin_expect_any_args.mock_function_declarations(function)
+    assert_equal(expected, returned)
+  end
+
   it "handle function declarations for functions without return values" do
-    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
+    function = {:name => "Mold", :args_string => "int meh", :args => [ :stuff ], :return => test_return[:void]}
     expected = "#define Mold_ExpectAnyArgs() Mold_CMockExpectAnyArgs(__LINE__)\nvoid Mold_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line);\n"
     returned = @cmock_generator_plugin_expect_any_args.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
 
   it "handle function declarations for functions that returns something" do
-    function = {:name => "Fungus", :args_string => "void", :return => test_return[:string]}
+    function = {:name => "Fungus", :args_string => "int meh", :args => [ :stuff ], :return => test_return[:string]}
     expected = "#define Fungus_ExpectAnyArgsAndReturn(cmock_retval) Fungus_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval)\n"+
                "void Fungus_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return);\n"
     returned = @cmock_generator_plugin_expect_any_args.mock_function_declarations(function)
@@ -46,11 +53,11 @@ describe CMockGeneratorPluginExpectAnyArgs, "Verify CMockGeneratorPluginExpectAn
   end
 
   it "add a new mock interface for ignoring when function had no return value" do
-    function = {:name => "Slime", :args => [], :args_string => "void", :return => test_return[:void]}
+    function = {:name => "Slime",  :args_string => "int meh", :args => [ :stuff ], :return => test_return[:void]}
     expected = ["void Slime_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line)\n",
                 "{\n",
                 "mock_return_1",
-                "  cmock_call_instance->IgnoreMode = CMOCK_ARG_NONE;\n",
+                "  cmock_call_instance->ExpectAnyArgsBool = (int)1;\n",
                 "}\n\n"
                ].join
     @utils.expect :code_add_base_expectation, "mock_return_1", ["Slime", true]

test/unit/cmock_generator_plugin_expect_b_test.rb

@@ -26,8 +26,8 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
   end
 
   it "have set up internal priority on init" do
-    assert_equal(nil,     @cmock_generator_plugin_expect.unity_helper)
-    assert_equal(5,       @cmock_generator_plugin_expect.priority)
+    assert_nil(@cmock_generator_plugin_expect.unity_helper)
+    assert_equal(5, @cmock_generator_plugin_expect.priority)
   end
 
   it "not include any additional include files" do
@@ -96,11 +96,12 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
   it "add mock function implementation for functions of style 'int func(int veal, unsigned int sushi)'" do
     function = {:name => "Cherry", :args => [ { :type => "int", :name => "veal" }, { :type => "unsigned int", :name => "sushi" } ], :return => test_return[:int]}
 
-    @utils.expect :code_verify_an_arg_expectation, " mocked_retval_1", [function, function[:args][0]]
-    @utils.expect :code_verify_an_arg_expectation, " mocked_retval_2", [function, function[:args][1]]
-    expected = "  if (cmock_call_instance->IgnoreMode != CMOCK_ARG_NONE)\n" +
+    @utils.expect :code_verify_an_arg_expectation, "mocked_retval_1\n", [function, function[:args][0]]
+    @utils.expect :code_verify_an_arg_expectation, "mocked_retval_2\n", [function, function[:args][1]]
+    expected = "  if (!cmock_call_instance->ExpectAnyArgsBool)\n" +
                "  {\n" +
-               " mocked_retval_1 mocked_retval_2\n" +
+               "mocked_retval_1\n" +
+               "mocked_retval_2\n" +
                "  }\n"
     returned = @cmock_generator_plugin_expect.mock_implementation(function)
     assert_equal(expected, returned)
@@ -116,8 +117,8 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
 
   it "add mock function implementation for functions of style 'void func(int worm)' and strict ordering" do
     function = {:name => "Apple", :args => [{ :type => "int", :name => "worm" }], :return => test_return[:void]}
-    @utils.expect :code_verify_an_arg_expectation, "mocked_retval_0", [function, function[:args][0]]
-    expected = "  if (cmock_call_instance->IgnoreMode != CMOCK_ARG_NONE)\n" +
+    @utils.expect :code_verify_an_arg_expectation, "mocked_retval_0\n", [function, function[:args][0]]
+    expected = "  if (!cmock_call_instance->ExpectAnyArgsBool)\n" +
                "  {\n" +
                "mocked_retval_0\n" +
                "  }\n"
@@ -128,13 +129,12 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
 
   it "add mock interfaces for functions of style 'void func(void)'" do
     function = {:name => "Pear", :args => [], :args_string => "void", :return => test_return[:void]}
-    @utils.expect :code_add_base_expectation, "mock_retval_0 ", ["Pear"]
-    @utils.expect :code_call_argument_loader, "mock_retval_1 ", [function]
+    @utils.expect :code_add_base_expectation, "mock_retval_0\n", ["Pear"]
+    @utils.expect :code_call_argument_loader, "mock_retval_1\n", [function]
     expected = ["void Pear_CMockExpect(UNITY_LINE_TYPE cmock_line)\n",
                 "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "  UNITY_CLR_DETAILS();\n",
+                "mock_retval_0\n",
+                "mock_retval_1\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -143,15 +143,14 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
 
   it "add mock interfaces for functions of style 'int func(void)'" do
     function = {:name => "Orange", :args => [], :args_string => "void", :return => test_return[:int]}
-    @utils.expect :code_add_base_expectation, "mock_retval_0 ", ["Orange"]
-    @utils.expect :code_call_argument_loader, "mock_retval_1 ", [function]
-    @utils.expect :code_assign_argument_quickly, "mock_retval_2", ["cmock_call_instance->ReturnVal", function[:return]]
+    @utils.expect :code_add_base_expectation, "mock_retval_0\n", ["Orange"]
+    @utils.expect :code_call_argument_loader, "mock_retval_1\n", [function]
+    @utils.expect :code_assign_argument_quickly, "mock_retval_2\n", ["cmock_call_instance->ReturnVal", function[:return]]
     expected = ["void Orange_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)\n",
                 "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "mock_retval_2",
-                "  UNITY_CLR_DETAILS();\n",
+                "mock_retval_0\n",
+                "mock_retval_1\n",
+                "mock_retval_2\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -160,15 +159,14 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
 
   it "add mock interfaces for functions of style 'int func(char* pescado)'" do
     function = {:name => "Lemon", :args => [{ :type => "char*", :name => "pescado"}], :args_string => "char* pescado", :return => test_return[:int]}
-    @utils.expect :code_add_base_expectation, "mock_retval_0 ", ["Lemon"]
-    @utils.expect :code_call_argument_loader, "mock_retval_1 ", [function]
-    @utils.expect :code_assign_argument_quickly, "mock_retval_2", ["cmock_call_instance->ReturnVal", function[:return]]
+    @utils.expect :code_add_base_expectation, "mock_retval_0\n", ["Lemon"]
+    @utils.expect :code_call_argument_loader, "mock_retval_1\n", [function]
+    @utils.expect :code_assign_argument_quickly, "mock_retval_2\n", ["cmock_call_instance->ReturnVal", function[:return]]
     expected = ["void Lemon_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, char* pescado, int cmock_to_return)\n",
                 "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "mock_retval_2",
-                "  UNITY_CLR_DETAILS();\n",
+                "mock_retval_0\n",
+                "mock_retval_1\n",
+                "mock_retval_2\n",
                 "}\n\n"
                ].join
     returned = @cmock_generator_plugin_expect.mock_interfaces(function)
@@ -177,13 +175,12 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
 
   it "add mock interfaces for functions when using ordering" do
     function = {:name => "Pear", :args => [], :args_string => "void", :return => test_return[:void]}
-    @utils.expect :code_add_base_expectation, "mock_retval_0 ", ["Pear"]
-    @utils.expect :code_call_argument_loader, "mock_retval_1 ", [function]
+    @utils.expect :code_add_base_expectation, "mock_retval_0\n", ["Pear"]
+    @utils.expect :code_call_argument_loader, "mock_retval_1\n", [function]
     expected = ["void Pear_CMockExpect(UNITY_LINE_TYPE cmock_line)\n",
                 "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "  UNITY_CLR_DETAILS();\n",
+                "mock_retval_0\n",
+                "mock_retval_1\n",
                 "}\n\n"
                ].join
     @cmock_generator_plugin_expect.ordered = true
@@ -194,7 +191,8 @@ describe CMockGeneratorPluginExpect, "Verify CMockGeneratorPluginExpect Module w
   it "add mock verify lines" do
     function = {:name => "Banana" }
     expected = "  UNITY_SET_DETAIL(CMockString_Banana);\n" +
-               "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.Banana_CallInstance, cmock_line, CMockStringCalledLess);\n"
+               "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == call_instance, cmock_line, CMockStringCalledLess);\n" +
+               "  UNITY_CLR_DETAILS();\n"
     returned = @cmock_generator_plugin_expect.mock_verify(function)
     assert_equal(expected, returned)
   end

test/unit/cmock_generator_plugin_ignore_arg_test.rb

@@ -21,9 +21,9 @@ describe CMockGeneratorPluginIgnoreArg, "Verify CMockGeneratorPluginIgnoreArg Mo
                                  :name => "chicken",
                                  :ptr? => false,
                                },
-                               { :type => "int*",
-                                 :name => "beef",
-                                 :ptr? => true,
+                               { :type   => "const int*",
+                                 :name   => "beef",
+                                 :ptr?   => true,
                                  :const? => true,
                                },
                                { :type => "int*",

test/unit/cmock_generator_plugin_return_thru_ptr_test.rb

@@ -27,9 +27,9 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
                                  :name => "chicken",
                                  :ptr? => false,
                                },
-                               { :type => "int*",
-                                 :name => "beef",
-                                 :ptr? => true,
+                               { :type   => "const int*",
+                                 :name   => "beef",
+                                 :ptr?   => true,
                                  :const? => true,
                                },
                                { :type => "int*",
@@ -52,7 +52,7 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
 
   def complex_func_expect
     @utils.expect :ptr_or_str?, false, ['int']
-    @utils.expect :ptr_or_str?, true, ['int*']
+    @utils.expect :ptr_or_str?, true, ['const int*']
     @utils.expect :ptr_or_str?, true, ['int*']
   end
 
@@ -89,7 +89,7 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
 
     expected =
       "#define Pine_ReturnThruPtr_tofu(tofu)" +
-      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, sizeof(*tofu))\n" +
+      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, sizeof(int))\n" +
       "#define Pine_ReturnArrayThruPtr_tofu(tofu, cmock_len)" +
       " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, (int)(cmock_len * (int)sizeof(*tofu)))\n" +
       "#define Pine_ReturnMemThruPtr_tofu(tofu, cmock_size)" +
@@ -124,11 +124,13 @@ describe CMockGeneratorPluginReturnThruPtr, "Verify CMockGeneratorPluginReturnTh
     expected =
       "  if (cmock_call_instance->ReturnThruPtr_tofu_Used)\n" +
       "  {\n" +
-      "    memcpy(tofu, cmock_call_instance->ReturnThruPtr_tofu_Val,\n" +
+      "    UNITY_TEST_ASSERT_NOT_NULL(tofu, cmock_line, CMockStringPtrIsNULL);\n" +
+      "    memcpy((void*)tofu, (void*)cmock_call_instance->ReturnThruPtr_tofu_Val,\n" +
       "      cmock_call_instance->ReturnThruPtr_tofu_Size);\n" +
-      "  }\n" +
+      "  }\n"
 
     returned = @cmock_generator_plugin_return_thru_ptr.mock_implementation(@complex_func).join("")
+    assert_equal(expected, returned)
   end
 
 end

test/unit/cmock_generator_utils_test.rb

@@ -20,7 +20,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     @config.expect :plugins, []
     @config.expect :plugins, []
     @config.expect :plugins, []
-    @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','char*' => 'STRING'}
+    @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','const char*' => 'STRING'}
     @cmock_generator_utils_simple = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper})
 
     @config.expect :when_ptr, :smart
@@ -31,7 +31,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
     @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
     @config.expect :plugins, [:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore]
-    @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','uint32_t' => 'HEX32','char*' => 'STRING'}
+    @config.expect :treat_as, {'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','uint32_t' => 'HEX32','const char*' => 'STRING'}
     @cmock_generator_utils_complex = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper, :A=>1, :B=>2})
   end
 
@@ -99,14 +99,15 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     arg1 = { :name => "Orange", :const? => false, :type => 'int', :ptr? => false }
     expected1 = "  cmock_call_instance->Expected_Orange = Orange;\n"
 
-    arg2 = { :name => "Lemon", :const? => true, :type => 'const char*', :ptr? => true }
-    expected2 = "  cmock_call_instance->Expected_Lemon = (const char*)Lemon;\n"
+    arg2 = { :name => "Lemon", :const? => true, :type => 'const char*', :ptr? => false }
+    expected2 = "  cmock_call_instance->Expected_Lemon = Lemon;\n"
 
     arg3 = { :name => "Kiwi", :const? => false, :type => 'KIWI_T*', :ptr? => true }
     expected3 = "  cmock_call_instance->Expected_Kiwi = Kiwi;\n"
 
     arg4 = { :name => "Lime", :const? => false, :type => 'LIME_T', :ptr? => false }
-    expected4 = "  memcpy(&cmock_call_instance->Expected_Lime, &Lime, sizeof(LIME_T));\n"
+    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (void*)(&Lime),\n" +
+                "         sizeof(LIME_T[sizeof(Lime) == sizeof(LIME_T) ? 1 : -1])); /* add LIME_T to :treat_as_array if this causes an error */\n"
 
     assert_equal(expected1, @cmock_generator_utils_simple.code_add_an_arg_expectation(arg1))
     assert_equal(expected2, @cmock_generator_utils_simple.code_add_an_arg_expectation(arg2))
@@ -119,8 +120,8 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected1 = "  cmock_call_instance->Expected_Orange = Orange;\n" +
                 "  cmock_call_instance->IgnoreArg_Orange = 0;\n"
 
-    arg2 = { :name => "Lemon", :const? => true, :type => 'const char*', :ptr? => true }
-    expected2 = "  cmock_call_instance->Expected_Lemon = (const char*)Lemon;\n" +
+    arg2 = { :name => "Lemon", :const? => true, :type => 'const char*', :ptr? => false }
+    expected2 = "  cmock_call_instance->Expected_Lemon = Lemon;\n" +
                 "  cmock_call_instance->Expected_Lemon_Depth = Lemon_Depth;\n" +
                 "  cmock_call_instance->IgnoreArg_Lemon = 0;\n"
 
@@ -131,7 +132,8 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                 "  cmock_call_instance->ReturnThruPtr_Kiwi_Used = 0;\n"
 
     arg4 = { :name => "Lime", :const? => false, :type => 'LIME_T', :ptr? => false }
-    expected4 = "  memcpy(&cmock_call_instance->Expected_Lime, &Lime, sizeof(LIME_T));\n" +
+    expected4 = "  memcpy((void*)(&cmock_call_instance->Expected_Lime), (void*)(&Lime),\n" +
+                "         sizeof(LIME_T[sizeof(Lime) == sizeof(LIME_T) ? 1 : -1])); /* add LIME_T to :treat_as_array if this causes an error */\n" +
                 "  cmock_call_instance->IgnoreArg_Lime = 0;\n"
 
     assert_equal(expected1, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg1))
@@ -151,10 +153,12 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
-    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff)\n{\n" +
+    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff);\n" +
+               "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, stuff)\n{\n" +
                "  cmock_call_instance->Expected_MyIntPtr = MyIntPtr;\n" +
-               "  memcpy(&cmock_call_instance->Expected_MyMyType, &MyMyType, sizeof(MY_TYPE));\n" +
-               "  cmock_call_instance->Expected_MyStr = (char*)MyStr;\n" +
+               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType),\n" +
+               "         sizeof(MY_TYPE[sizeof(MyMyType) == sizeof(MY_TYPE) ? 1 : -1])); /* add MY_TYPE to :treat_as_array if this causes an error */\n" +
+               "  cmock_call_instance->Expected_MyStr = MyStr;\n" +
                "}\n\n"
     assert_equal(expected, @cmock_generator_utils_simple.code_add_argument_loader(function))
   end
@@ -164,19 +168,39 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
-    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr)\n{\n" +
+    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr);\n" +
+               "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* MyIntPtr, int MyIntPtr_Depth, const MY_TYPE MyMyType, const char* MyStr)\n{\n" +
                "  cmock_call_instance->Expected_MyIntPtr = MyIntPtr;\n" +
                "  cmock_call_instance->Expected_MyIntPtr_Depth = MyIntPtr_Depth;\n" +
                "  cmock_call_instance->IgnoreArg_MyIntPtr = 0;\n" +
                "  cmock_call_instance->ReturnThruPtr_MyIntPtr_Used = 0;\n" +
-               "  memcpy(&cmock_call_instance->Expected_MyMyType, &MyMyType, sizeof(MY_TYPE));\n" +
+               "  memcpy((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType),\n" +
+               "         sizeof(MY_TYPE[sizeof(MyMyType) == sizeof(MY_TYPE) ? 1 : -1])); /* add MY_TYPE to :treat_as_array if this causes an error */\n" +
                "  cmock_call_instance->IgnoreArg_MyMyType = 0;\n" +
-               "  cmock_call_instance->Expected_MyStr = (char*)MyStr;\n" +
+               "  cmock_call_instance->Expected_MyStr = MyStr;\n" +
                "  cmock_call_instance->IgnoreArg_MyStr = 0;\n" +
                "}\n\n"
     assert_equal(expected, @cmock_generator_utils_complex.code_add_argument_loader(function))
   end
 
+  it 'create an argument loader when the function has pointer arguments supporting arrays' do
+    function = { :name => "Melon",
+                 :args_string => "stuff",
+                 :args => [test_arg[:const_ptr], test_arg[:double_ptr]]
+    }
+    expected = "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* const MyConstPtr, int MyConstPtr_Depth, int const** MyDoublePtr, int MyDoublePtr_Depth);\n" +
+               "void CMockExpectParameters_Melon(CMOCK_Melon_CALL_INSTANCE* cmock_call_instance, int* const MyConstPtr, int MyConstPtr_Depth, int const** MyDoublePtr, int MyDoublePtr_Depth)\n{\n" +
+               "  cmock_call_instance->Expected_MyConstPtr = MyConstPtr;\n" +
+               "  cmock_call_instance->Expected_MyConstPtr_Depth = MyConstPtr_Depth;\n" +
+               "  cmock_call_instance->IgnoreArg_MyConstPtr = 0;\n" +
+               "  cmock_call_instance->ReturnThruPtr_MyConstPtr_Used = 0;\n" +
+               "  cmock_call_instance->Expected_MyDoublePtr = MyDoublePtr;\n" +
+               "  cmock_call_instance->Expected_MyDoublePtr_Depth = MyDoublePtr_Depth;\n" +
+               "  cmock_call_instance->IgnoreArg_MyDoublePtr = 0;\n" +
+               "}\n\n"
+    assert_equal(expected, @cmock_generator_utils_complex.code_add_argument_loader(function))
+  end
+
   it "not call argument loader if there are no arguments to actually use for this function" do
     function = { :name => "Pineapple", :args_string => "void" }
 
@@ -231,7 +255,7 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
                "    UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_MyStr, MyStr, cmock_line, CMockStringMismatch);\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
-    @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_STRING',''], ['char*']
+    @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_STRING',''], ['const char*']
     assert_equal(expected, @cmock_generator_utils_simple.code_verify_an_arg_expectation(function, arg))
   end
 
@@ -277,7 +301,9 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyInt)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyInt);\n" +
+               "    if (cmock_call_instance->Expected_MyInt != MyInt) {\n" +
                "    UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_MyInt, MyInt, cmock_line, CMockStringMismatch);\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_INT',''], ['int']
@@ -290,12 +316,14 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyIntPtr)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyIntPtr);\n" +
+               "    if (cmock_call_instance->Expected_MyIntPtr != MyIntPtr) {\n" +
                "    if (cmock_call_instance->Expected_MyIntPtr == NULL)\n" +
                "      { UNITY_TEST_ASSERT_NULL(MyIntPtr, cmock_line, CMockStringExpNULL); }\n" +
                "    else if (cmock_call_instance->Expected_MyIntPtr_Depth == 0)\n" +
                "      { UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_MyIntPtr, MyIntPtr, cmock_line, CMockStringMismatch); }\n" +
                "    else\n" +
                "      { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_MyIntPtr, MyIntPtr, cmock_call_instance->Expected_MyIntPtr_Depth, cmock_line, CMockStringMismatch); }\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_INT_ARRAY',''], ['int*']
@@ -308,10 +336,12 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyStr)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyStr);\n" +
+               "    if (cmock_call_instance->Expected_MyStr != MyStr) {\n" +
                "    UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_MyStr, MyStr, cmock_line, CMockStringMismatch);\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
-    @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_STRING',''], ['char*']
+    @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_STRING',''], ['const char*']
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
 
@@ -321,10 +351,12 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyMyType)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyMyType);\n" +
+               "    if (cmock_call_instance->Expected_MyMyType != MyMyType) {\n" +
                "    if (cmock_call_instance->Expected_MyMyType == NULL)\n" +
                "      { UNITY_TEST_ASSERT_NULL(MyMyType, cmock_line, CMockStringExpNULL); }\n" +
                "    else\n" +
                "      { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_MyMyType), (void*)(MyMyType), sizeof(MY_TYPE), 1, cmock_line, CMockStringMismatch); }\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY', ''],  ['MY_TYPE']
@@ -337,7 +369,9 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyMyType)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyMyType);\n" +
+               "    if (cmock_call_instance->Expected_MyMyType != MyMyType) {\n" +
                "    UNITY_TEST_ASSERT_EQUAL_MY_TYPE(cmock_call_instance->Expected_MyMyType, MyMyType, cmock_line, CMockStringMismatch);\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MY_TYPE',  ''], ['MY_TYPE']
@@ -350,12 +384,14 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyMyTypePtr)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyMyTypePtr);\n" +
+               "    if (cmock_call_instance->Expected_MyMyTypePtr != MyMyTypePtr) {\n" +
                "    if (cmock_call_instance->Expected_MyMyTypePtr == NULL)\n" +
                "      { UNITY_TEST_ASSERT_NULL(MyMyTypePtr, cmock_line, CMockStringExpNULL); }\n" +
                "    else if (cmock_call_instance->Expected_MyMyTypePtr_Depth == 0)\n" +
                "      { UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_MyMyTypePtr, MyMyTypePtr, cmock_line, CMockStringMismatch); }\n" +
                "    else\n" +
                "      { UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY(cmock_call_instance->Expected_MyMyTypePtr, MyMyTypePtr, cmock_call_instance->Expected_MyMyTypePtr_Depth, cmock_line, CMockStringMismatch); }\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY', ''], ['MY_TYPE*']
@@ -368,7 +404,9 @@ describe CMockGeneratorUtils, "Verify CMockGeneratorUtils Module" do
     expected = "  if (!cmock_call_instance->IgnoreArg_MyMyType)\n" +
                "  {\n" +
                "    UNITY_SET_DETAILS(CMockString_Pear,CMockString_MyMyType);\n" +
+               "    if (&cmock_call_instance->Expected_MyMyType != &MyMyType) {\n" +
                "    UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY(&cmock_call_instance->Expected_MyMyType, &MyMyType, 1, cmock_line, CMockStringMismatch);\n" +
+               "    }\n" +
                "  }\n"
     @unity_helper.expect :nil?, false
     @unity_helper.expect :get_helper, ['UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY', '&'], ['MY_TYPE']

test/unit/cmock_header_parser_test.rb

@@ -19,9 +19,12 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     @config.expect :c_calling_conventions, ['__stdcall']
     @config.expect :treat_as_void, ['MY_FUNKY_VOID']
     @config.expect :treat_as, { "BANJOS" => "INT", "TUBAS" => "HEX16"}
+    @config.expect :treat_as_array, {"IntArray" => "int", "Book" => "Page"}
     @config.expect :when_no_prototypes, :error
     @config.expect :verbosity, 1
     @config.expect :treat_externs, :exclude
+    @config.expect :array_size_type, ['int', 'size_t']
+    @config.expect :array_size_name, 'size|len'
 
     @parser = CMockHeaderParser.new(@config)
   end
@@ -805,6 +808,64 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.parse("module", source)[:functions])
   end
 
+  it "should properly handle const before return type" do
+    sources = [
+      "const int * PorkRoast(void);\n",
+      "const int* PorkRoast(void);\n",
+      "const int *PorkRoast(void);\n"
+    ]
+
+    expected = [{ :var_arg => nil,
+                  :name    => "PorkRoast",
+                  :return  => { :type       => "const int*",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => true,
+                                :const?     => true,
+                                :const_ptr? => false,
+                                :str        => "const int* cmock_to_return",
+                                :void?      => false
+                              },
+                  :modifier      => "",
+                  :contains_ptr? => false,
+                  :args          => [],
+                  :args_string   => "void",
+                  :args_call     => ""
+                }]
+
+    sources.each do |source|
+      assert_equal(expected, @parser.parse("module", source)[:functions])
+    end
+  end
+
+  it "should properly handle const before return type" do
+    sources = [
+      "int const * PorkRoast(void);\n",
+      "int const* PorkRoast(void);\n",
+      "int const *PorkRoast(void);\n"
+    ]
+
+    expected = [{ :var_arg => nil,
+                  :name    => "PorkRoast",
+                  :return  => { :type       => "int const*",
+                                :name       => 'cmock_to_return',
+                                :ptr?       => true,
+                                :const?     => true,
+                                :const_ptr? => false,
+                                :str        => "int const* cmock_to_return",
+                                :void?      => false
+                              },
+                  :modifier      => "",
+                  :contains_ptr? => false,
+                  :args          => [],
+                  :args_string   => "void",
+                  :args_call     => ""
+                }]
+
+    sources.each do |source|
+      assert_equal(expected, @parser.parse("module", source)[:functions])
+    end
+  end
+
   it "should properly handle const applied after asterisk in return type (not legal C, but sometimes used)" do
 
     source = "int * const PorkRoast(void);\n"
@@ -828,6 +889,95 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.parse("module", source)[:functions])
   end
 
+  it "properly parse const and pointer argument types with no arg names" do
+
+    source = "void foo(int const*, int*const, const int*, const int*const, int const*const, int*, int, const int);\n"
+
+    expected = [{ :name => "foo",
+                  :modifier => "",
+                  :return => { :type       => "void",
+                               :name       => "cmock_to_return",
+                               :str        => "void cmock_to_return",
+                               :void?      => true,
+                               :ptr?       => false,
+                               :const?     => false,
+                               :const_ptr? => false
+                             },
+                  :var_arg => nil,
+                  :args_string => "int const* cmock_arg1, int* const cmock_arg2, const int* cmock_arg3, const int* const cmock_arg4, " +
+                                  "int const* const cmock_arg5, int* cmock_arg6, int cmock_arg7, const int cmock_arg8",
+                  :args => [{ :type=>"int const*", :name => "cmock_arg1", :ptr? => true,  :const? => true,  :const_ptr? => false },
+                            { :type=>"int*",       :name => "cmock_arg2", :ptr? => true,  :const? => false, :const_ptr? => true  },
+                            { :type=>"const int*", :name => "cmock_arg3", :ptr? => true,  :const? => true,  :const_ptr? => false },
+                            { :type=>"const int*", :name => "cmock_arg4", :ptr? => true,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int const*", :name => "cmock_arg5", :ptr? => true,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int*",       :name => "cmock_arg6", :ptr? => true,  :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "cmock_arg7", :ptr? => false, :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "cmock_arg8", :ptr? => false, :const? => true,  :const_ptr? => false }],
+                  :args_call => "cmock_arg1, cmock_arg2, cmock_arg3, cmock_arg4, cmock_arg5, cmock_arg6, cmock_arg7, cmock_arg8",
+                  :contains_ptr? => true
+                }]
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "properly parse const and pointer argument types with arg names" do
+
+    source = "void bar(int const* param1, int*const param2, const int* param3, const int*const param4,\n" +
+             "         int const*const param5, int*param6, int param7, const int param8);\n"
+
+    expected = [{ :name => "bar",
+                  :modifier => "",
+                  :return => { :type       => "void",
+                               :name       => "cmock_to_return",
+                               :str        => "void cmock_to_return",
+                               :void?      => true,
+                               :ptr?       => false,
+                               :const?     => false,
+                               :const_ptr? => false
+                             },
+                  :var_arg => nil,
+                  :args_string => "int const* param1, int* const param2, const int* param3, const int* const param4, " +
+                                  "int const* const param5, int* param6, int param7, const int param8",
+                  :args => [{ :type=>"int const*", :name => "param1", :ptr? => true,  :const? => true,  :const_ptr? => false },
+                            { :type=>"int*",       :name => "param2", :ptr? => true,  :const? => false, :const_ptr? => true  },
+                            { :type=>"const int*", :name => "param3", :ptr? => true,  :const? => true,  :const_ptr? => false },
+                            { :type=>"const int*", :name => "param4", :ptr? => true,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int const*", :name => "param5", :ptr? => true,  :const? => true,  :const_ptr? => true  },
+                            { :type=>"int*",       :name => "param6", :ptr? => true,  :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "param7", :ptr? => false, :const? => false, :const_ptr? => false },
+                            { :type=>"int",        :name => "param8", :ptr? => false, :const? => true,  :const_ptr? => false }],
+                  :args_call => "param1, param2, param3, param4, param5, param6, param7, param8",
+                  :contains_ptr? => true
+                }]
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+  end
+
+  it "converts typedef'd array arguments to pointers" do
+
+    source = "Book AddToBook(Book book, const IntArray values);\n"
+
+    expected = [{ :name => "AddToBook",
+                  :modifier=>"",
+                  :return  => { :type       => "Book",
+                                :name       => "cmock_to_return",
+                                :str        => "Book cmock_to_return",
+                                :void?      => false,
+                                :ptr?       => false,
+                                :const?     => false,
+                                :const_ptr? => false
+                              },
+                  :var_arg => nil,
+                  :args => [{ :type => "Page*",      :name => "book",   :ptr? => true, :const? => false, :const_ptr? => false },
+                            { :type => "const int*", :name => "values", :ptr? => true, :const? => true,  :const_ptr? => false }],
+                  :args_string => "Book book, const IntArray values",
+                  :args_call => "book, values",
+                  :contains_ptr? => true
+                }]
+
+    assert_equal(expected, @parser.parse("module", source)[:functions])
+
+  end
+
   it "properly detect typedef'd variants of void and use those" do
 
     source = "typedef (void) FUNKY_VOID_T;\n" +
@@ -904,7 +1054,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                   :name=>"Penny",
                   :modifier=>"",
                   :contains_ptr? => true,
-                  :args=>[ {:type=>"struct _KeepYourHeadUp_*", :name=>"BillyBuddy", :ptr? => true, :const? => true, :const_ptr? => true} ],
+                  :args=>[ {:type=>"struct const _KeepYourHeadUp_*", :name=>"BillyBuddy", :ptr? => true, :const? => true, :const_ptr? => true} ],
                   :args_string=>"struct const _KeepYourHeadUp_* const BillyBuddy",
                   :args_call=>"BillyBuddy"
                 },
@@ -1052,7 +1202,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, result[:functions])
   end
 
-  it "handle arrays and treat them as pointers" do
+  it "handle arrays and treat them as pointers or strings" do
     source = "void KeyOperated(CUSTOM_TYPE thing1[], int thing2 [ ], char thing3 [][2 ][ 3], int* thing4[4])"
     expected = [{:var_arg=>nil,
                  :return=>{ :type   => "void",
@@ -1068,7 +1218,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                  :contains_ptr? => true,
                  :args=>[ {:type=>"CUSTOM_TYPE*", :name=>"thing1", :ptr? => true, :const? => false, :const_ptr? => false},
                           {:type=>"int*", :name=>"thing2", :ptr? => true, :const? => false, :const_ptr? => false},
-                          {:type=>"char*", :name=>"thing3", :ptr? => true, :const? => false, :const_ptr? => false},  #THIS one will likely change in the future when we improve multidimensional array support
+                          {:type=>"char*", :name=>"thing3", :ptr? => false, :const? => false, :const_ptr? => false},  #THIS one will likely change in the future when we improve multidimensional array support
                           {:type=>"int**", :name=>"thing4", :ptr? => true, :const? => false, :const_ptr? => false}    #THIS one will likely change in the future when we improve multidimensional array support
                         ],
                  :args_string=>"CUSTOM_TYPE* thing1, int* thing2, char* thing3, int** thing4",
@@ -1407,7 +1557,7 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
                    :contains_ptr? => true,
                    :args=>[ {:type=>"sqlite3_stmt*", :name=>"cmock_arg2", :ptr? => true, :const? => false, :const_ptr? => false},
                             {:type=>"int", :name=>"cmock_arg3", :ptr? => false, :const? => false, :const_ptr? => false},
-                            {:type=>"char*", :name=>"cmock_arg4", :ptr? => true, :const? => true, :const_ptr? => false},
+                            {:type=>"const char*", :name=>"cmock_arg4", :ptr? => false, :const? => true, :const_ptr? => false},
                             {:type=>"int", :name=>"n", :ptr? => false, :const? => false, :const_ptr? => false},
                             {:type=>"cmock_module_func_ptr1", :name=>"cmock_arg1", :ptr? => false, :const? => false, :const_ptr? => false}
                           ],
@@ -1510,4 +1660,69 @@ describe CMockHeaderParser, "Verify CMockHeaderParser Module" do
     assert_equal(expected, @parser.parse("module", source)[:functions])
   end
 
+  it "divines all permutations of ptr, const, and const_ptr correctly" do
+    truth_table = [
+      # argument                                           ptr    const  const_ptr
+      [ "constNOTconst constNOTconst",                     false, false, false ],
+      [ "const constNOTconst constNOTconst",               false, true,  false ],
+      [ "constNOTconst const constNOTconst",               false, true,  false ],
+      [ "constNOTconst *constNOTconst",                    true,  false, false ],
+      [ "const constNOTconst *constNOTconst",              true,  true,  false ],
+      [ "constNOTconst const *constNOTconst",              true,  true,  false ],
+      [ "constNOTconst *const constNOTconst",              true,  false, true ],
+      [ "const constNOTconst *const constNOTconst",        true,  true,  true ],
+      [ "constNOTconst const *const constNOTconst",        true,  true,  true ],
+      [ "constNOTconst **constNOTconst",                   true,  false, false ],
+      [ "const constNOTconst **constNOTconst",             true,  false, false ],
+      [ "constNOTconst const **constNOTconst",             true,  false, false ],
+      [ "constNOTconst *const *constNOTconst",             true,  true,  false ],
+      [ "const constNOTconst *const *constNOTconst",       true,  true,  false ],
+      [ "constNOTconst const *const *constNOTconst",       true,  true,  false ],
+      [ "constNOTconst **const constNOTconst",             true,  false, true ],
+      [ "const constNOTconst **const constNOTconst",       true,  false, true ],
+      [ "constNOTconst const **const constNOTconst",       true,  false, true ],
+      [ "constNOTconst *const *const constNOTconst",       true,  true,  true ],
+      [ "const constNOTconst *const *const constNOTconst", true,  true,  true ],
+      [ "constNOTconst const *const *const constNOTconst", true,  true,  true ]
+    ]
+
+    truth_table.each do |entry|
+      assert_equal(@parser.divine_ptr(entry[0]), entry[1])
+      assert_equal(@parser.divine_const(entry[0]), entry[2])
+      assert_equal(@parser.divine_ptr_and_const(entry[0]),
+        { ptr?: entry[1], const?: entry[2], const_ptr?: entry[3] })
+    end
+  end
+
+  it "divines ptr correctly for string types" do
+    truth_table = [
+      # argument                      ptr
+      [ "char s",                     false ],
+      [ "const char s",               false ],
+      [ "char const s",               false ],
+      [ "char *s",                    false ],
+      [ "const char *s",              false ],
+      [ "char const *s",              false ],
+      [ "char *const s",              false ],
+      [ "const char *const s",        false ],
+      [ "char const *const s",        false ],
+      [ "char **s",                   true  ],
+      [ "const char **s",             true  ],
+      [ "char const **s",             true  ],
+      [ "char *const *s",             true  ],
+      [ "const char *const *s",       true  ],
+      [ "char const *const *s",       true  ],
+      [ "char **const s",             true  ],
+      [ "const char **const s",       true  ],
+      [ "char const **const s",       true  ],
+      [ "char *const *const s",       true  ],
+      [ "const char *const *const s", true  ],
+      [ "char const *const *const s", true  ]
+    ]
+
+    truth_table.each do |entry|
+      assert_equal(@parser.divine_ptr(entry[0]), entry[1])
+    end
+  end
+
 end

test/unit/cmock_plugin_manager_test.rb

@@ -21,8 +21,17 @@ describe CMockPluginManager, "Verify CMockPluginManager Module" do
       :ignore => :args_and_calls
     )
 
-    eval "class << @config\ndef plugins\n@plugins||[]\nend\ndef plugins=(val)\n@plugins=val\nend\nend\n"
+    def @config.plugins
+      if instance_variable_defined?(:@plugins)
+        @plugins || []
+      else
+        []
+      end
+    end
 
+    def @config.plugins=(val)
+      @plugins = val
+    end
   end
 
   after do