ceedling 0.15.1 → 0.15.2

data/vendor/cmock/test/unit/cmock_generator_plugin_expect_any_args_test.rb

@@ -0,0 +1,82 @@
+# ==========================================
+#   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 File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'cmock_generator_plugin_expect_any_args.rb'
+
+class CMockGeneratorPluginExpectAnyArgsTest < Test::Unit::TestCase
+  def setup
+    create_mocks :config, :utils
+    @config.stubs!(:respond_to?).returns(true)
+    @cmock_generator_plugin_expect_any_args = CMockGeneratorPluginExpectAnyArgs.new(@config, @utils)
+  end
+
+  def teardown
+  end
+
+  should "have set up internal accessors correctly on init" do
+    assert_equal(@config, @cmock_generator_plugin_expect_any_args.config)
+    assert_equal(@utils,  @cmock_generator_plugin_expect_any_args.utils)
+    assert_equal(3,       @cmock_generator_plugin_expect_any_args.priority)
+  end
+
+  should "not have any additional include file requirements" do
+    assert(!@cmock_generator_plugin_expect_any_args.respond_to?(:include_files))
+  end
+
+  should "handle function declarations for functions without return values" do
+    function = {:name => "Mold", :args_string => "void", :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
+
+  should "handle function declarations for functions that returns something" do
+    function = {:name => "Fungus", :args_string => "void", :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)
+    assert_equal(expected, returned)
+  end
+
+  should "add required code to implementation with void function" do
+    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
+    expected = ["  if (cmock_call_instance->IgnoreMode == CMOCK_ARG_NONE)\n",
+                "  {\n",
+                "    return;\n",
+                "  }\n"
+               ].join
+    returned = @cmock_generator_plugin_expect_any_args.mock_implementation(function)
+    assert_equal(expected, returned)
+  end
+
+  should "add required code to implementation with return functions" do
+    function = {:name => "Fungus", :args_string => "void", :return => test_return[:int]}
+    retval = test_return[:int].merge({ :name => "cmock_call_instance->ReturnVal"})
+    @utils.expect.code_assign_argument_quickly("Mock.Fungus_FinalReturn", retval).returns('  mock_retval_0')
+    expected = ["  if (cmock_call_instance->IgnoreMode == CMOCK_ARG_NONE)\n",
+                "  {\n",
+                "    mock_retval_0",
+                "    return cmock_call_instance->ReturnVal;\n",
+                "  }\n"
+               ].join
+    returned = @cmock_generator_plugin_expect_any_args.mock_implementation(function)
+    assert_equal(expected, returned)
+  end
+
+  should "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]}
+    expected = ["void Slime_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line)\n",
+                "{\n",
+                "mock_return_1",
+                "  cmock_call_instance->IgnoreMode = CMOCK_ARG_NONE;\n",
+                "}\n\n"
+               ].join
+    @utils.expect.code_add_base_expectation("Slime", true).returns("mock_return_1")
+    returned = @cmock_generator_plugin_expect_any_args.mock_interfaces(function)
+    assert_equal(expected, returned)
+  end
+end

data/vendor/cmock/test/unit/cmock_generator_plugin_ignore_test.rb

@@ -2,7 +2,7 @@
 #   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 File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require 'cmock_generator_plugin_ignore'
@@ -10,50 +10,37 @@ require 'cmock_generator_plugin_ignore'
 class CMockGeneratorPluginIgnoreTest < Test::Unit::TestCase
   def setup
     create_mocks :config, :utils
-    @config.expect.ignore.returns(:args_and_calls)
     @config.stubs!(:respond_to?).returns(true)
     @cmock_generator_plugin_ignore = CMockGeneratorPluginIgnore.new(@config, @utils)
-    
-    @config.expect.ignore.returns(:args_only)
-    @cmock_generator_plugin_ignore_just_args = CMockGeneratorPluginIgnore.new(@config, @utils)
   end
 
   def teardown
   end
-  
+
   should "have set up internal accessors correctly on init" do
     assert_equal(@config, @cmock_generator_plugin_ignore.config)
     assert_equal(@utils,  @cmock_generator_plugin_ignore.utils)
     assert_equal(2,       @cmock_generator_plugin_ignore.priority)
   end
-  
+
   should "not have any additional include file requirements" do
     assert(!@cmock_generator_plugin_ignore.respond_to?(:include_files))
   end
-  
+
   should "add a required variable to the instance structure" do
     function = {:name => "Grass", :args => [], :return => test_return[:void]}
     expected = "  int Grass_IgnoreBool;\n"
     returned = @cmock_generator_plugin_ignore.instance_structure(function)
     assert_equal(expected, returned)
   end
-  
-  should "handle function declarations for functions without return values when args_only" do
-    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
-    expected = "#define Mold_Ignore() Mold_CMockIgnore(__LINE__)\nvoid Mold_CMockIgnore(UNITY_LINE_TYPE cmock_line);\n"
-    @config.expect.ignore.returns(:args_only)
-    returned = @cmock_generator_plugin_ignore.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "handle function declarations for functions without return values when args_and_calls" do
+
+  should "handle function declarations for functions without return values" do
     function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
     expected = "#define Mold_Ignore() Mold_CMockIgnore()\nvoid Mold_CMockIgnore(void);\n"
-    @config.expect.ignore.returns(:args_and_calls)
     returned = @cmock_generator_plugin_ignore.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
-  
+
   should "handle function declarations for functions that returns something" do
     function = {:name => "Fungus", :args_string => "void", :return => test_return[:string]}
     expected = "#define Fungus_IgnoreAndReturn(cmock_retval) Fungus_CMockIgnoreAndReturn(__LINE__, cmock_retval)\n"+
@@ -61,69 +48,34 @@ class CMockGeneratorPluginIgnoreTest < Test::Unit::TestCase
     returned = @cmock_generator_plugin_ignore.mock_function_declarations(function)
     assert_equal(expected, returned)
   end
-  
-  should "add required code to implementation precheck with void function (when :args_and_calls)" do
+
+  should "add required code to implementation precheck with void function" do
     function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
     expected = ["  if (Mock.Mold_IgnoreBool)\n",
                 "  {\n",
                 "    return;\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_ignore.mock_implementation_for_ignores(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add required code to implementation precheck with return functions (when :args_and_calls)" do
-    function = {:name => "Fungus", :args_string => "void", :return => test_return[:int]}
-    retval = test_return[:int].merge({ :name => "cmock_call_instance->ReturnVal"})
-    @utils.expect.code_assign_argument_quickly("Mock.Fungus_FinalReturn", retval).returns('  mock_retval_0')
-    expected = ["  if (Mock.Fungus_IgnoreBool)\n",
-                "  {\n",
-                "    if (cmock_call_instance == NULL)\n",
-                "      return Mock.Fungus_FinalReturn;\n",
-                "    mock_retval_0",
-                "    return cmock_call_instance->ReturnVal;\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_ignore.mock_implementation_for_ignores(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "not add code to implementation prefix (when :args_only)" do
-    function = {:name => "Fungus", :args_string => "void", :return => test_return[:int]}
-    retval = test_return[:int].merge({ :name => "cmock_call_instance->ReturnVal"})
-    expected = ""
     returned = @cmock_generator_plugin_ignore.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
-  
-  should "add required code to implementation with void function (when :args_only)" do
-    function = {:name => "Mold", :args_string => "void", :return => test_return[:void]}
-    expected = ["  if (Mock.Mold_IgnoreBool)\n",
-                "  {\n",
-                "    return;\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_ignore_just_args.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add required code to implementation with return functions (when :args_only)" do
+
+  should "add required code to implementation precheck with return functions" do
     function = {:name => "Fungus", :args_string => "void", :return => test_return[:int]}
     retval = test_return[:int].merge({ :name => "cmock_call_instance->ReturnVal"})
     @utils.expect.code_assign_argument_quickly("Mock.Fungus_FinalReturn", retval).returns('  mock_retval_0')
     expected = ["  if (Mock.Fungus_IgnoreBool)\n",
                 "  {\n",
                 "    if (cmock_call_instance == NULL)\n",
-                "      return Mock.Fungus_FinalReturn;\n",
+                "      return (int)Mock.Fungus_FinalReturn;\n",
                 "    mock_retval_0",
-                "    return cmock_call_instance->ReturnVal;\n",
+                "    return (int)cmock_call_instance->ReturnVal;\n",
                 "  }\n"
                ].join
-    returned = @cmock_generator_plugin_ignore_just_args.mock_implementation(function)
+    returned = @cmock_generator_plugin_ignore.mock_implementation_precheck(function)
     assert_equal(expected, returned)
   end
-  
+
   should "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]}
     expected = ["void Slime_CMockIgnore(void)\n",
@@ -131,28 +83,12 @@ class CMockGeneratorPluginIgnoreTest < Test::Unit::TestCase
                 "  Mock.Slime_IgnoreBool = (int)1;\n",
                 "}\n\n"
                ].join
-    @config.expect.ignore.returns(:args_and_calls)
-    returned = @cmock_generator_plugin_ignore.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add a new mock interface for ignoring when function had no return value and we are checking args only" do
-    function = {:name => "Slime", :args => [], :args_string => "void", :return => test_return[:void]}
-    expected = ["void Slime_CMockIgnore(UNITY_LINE_TYPE cmock_line)\n",
-                "{\n",
-                "mock_return_1",
-                "  Mock.Slime_IgnoreBool = (int)1;\n",
-                "}\n\n"
-               ].join
-    @config.expect.ignore.returns(:args_only)
-    @utils.expect.code_add_base_expectation("Slime", true).returns("mock_return_1")
     returned = @cmock_generator_plugin_ignore.mock_interfaces(function)
     assert_equal(expected, returned)
   end
-  
+
   should "add a new mock interface for ignoring when function has return value" do
     function = {:name => "Slime", :args => [], :args_string => "void", :return => test_return[:int]}
-    @config.expect.ignore.returns(:args_and_calls)
     @utils.expect.code_add_base_expectation("Slime", false).returns("mock_return_1")
     expected = ["void Slime_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)\n",
                 "{\n",
@@ -164,5 +100,5 @@ class CMockGeneratorPluginIgnoreTest < Test::Unit::TestCase
     returned = @cmock_generator_plugin_ignore.mock_interfaces(function)
     assert_equal(expected, returned)
   end
-  
+
 end

data/vendor/cmock/test/unit/cmock_generator_plugin_return_thru_ptr_test.rb

@@ -2,7 +2,7 @@
 #   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 File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require 'cmock_generator_plugin_return_thru_ptr'
@@ -21,7 +21,7 @@ class CMockGeneratorPluginReturnThruPtrTest < Test::Unit::TestCase
                     :contains_ptr? => false}
 
     # void Pine(int chicken, const int beef, int *tofu)
-    @complex_func = {:name => "Pine", 
+    @complex_func = {:name => "Pine",
                      :args => [{ :type => "int",
                                  :name => "chicken",
                                  :ptr? => false,
@@ -35,7 +35,7 @@ class CMockGeneratorPluginReturnThruPtrTest < Test::Unit::TestCase
                                  :name => "tofu",
                                  :ptr? => true,
                                }],
-                     :return => test_return[:void], 
+                     :return => test_return[:void],
                      :contains_ptr? => true }
 
     #no strict ordering
@@ -54,13 +54,13 @@ class CMockGeneratorPluginReturnThruPtrTest < Test::Unit::TestCase
     @utils.expect.ptr_or_str?('int*').returns(true)
     @utils.expect.ptr_or_str?('int*').returns(true)
   end
-  
+
   should "have set up internal accessors correctly on init" do
     assert_equal(@utils,  @cmock_generator_plugin_return_thru_ptr.utils)
-    assert_equal(9,       @cmock_generator_plugin_return_thru_ptr.priority)
+    assert_equal(1,       @cmock_generator_plugin_return_thru_ptr.priority)
   end
-  
-  should "not include any additional include files" do 
+
+  should "not include any additional include files" do
     assert(!@cmock_generator_plugin_return_thru_ptr.respond_to?(:include_files))
   end
 
@@ -68,7 +68,7 @@ class CMockGeneratorPluginReturnThruPtrTest < Test::Unit::TestCase
     returned = @cmock_generator_plugin_return_thru_ptr.instance_typedefs(@void_func)
     assert_equal("", returned)
   end
-  
+
   should "add to tyepdef structure mock needs of functions of style 'void func(int chicken, int* pork)'" do
     complex_func_expect()
     expected = "  int ReturnThruPtr_tofu_Used;\n" +
@@ -86,12 +86,12 @@ class CMockGeneratorPluginReturnThruPtrTest < Test::Unit::TestCase
 
   should "add a mock function declaration only for non-const pointer arguments" do
     complex_func_expect();
-    
+
     expected =
       "#define Pine_ReturnThruPtr_tofu(tofu)" +
       " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, sizeof(*tofu))\n" +
       "#define Pine_ReturnArrayThruPtr_tofu(tofu, cmock_len)" +
-      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, cmock_len * sizeof(*tofu))\n" +
+      " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, (int)(cmock_len * (int)sizeof(*tofu)))\n" +
       "#define Pine_ReturnMemThruPtr_tofu(tofu, cmock_size)" +
       " Pine_CMockReturnMemThruPtr_tofu(__LINE__, tofu, cmock_size)\n" +
       "void Pine_CMockReturnMemThruPtr_tofu(UNITY_LINE_TYPE cmock_line, int* tofu, int cmock_size);\n"

data/vendor/cmock/test/unit/cmock_generator_utils_test.rb

@@ -2,7 +2,7 @@
 #   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 File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
 require 'cmock_generator_utils'
@@ -10,36 +10,40 @@ require 'cmock_generator_utils'
 class CMockGeneratorUtilsTest < Test::Unit::TestCase
   def setup
     create_mocks :config, :unity_helper, :unity_helper
-    
+
     @config.expect.when_ptr.returns(:compare_ptr)
     @config.expect.enforce_strict_ordering.returns(false)
     @config.expect.plugins.returns([])
     @config.expect.plugins.returns([])
     @config.expect.plugins.returns([])
     @config.expect.plugins.returns([])
+    @config.expect.plugins.returns([])
+    @config.expect.plugins.returns([])
     @config.expect.treat_as.returns({'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','char*' => 'STRING'})
     @cmock_generator_utils_simple = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper})
 
     @config.expect.when_ptr.returns(:smart)
     @config.expect.enforce_strict_ordering.returns(true)
-    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg])
-    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg])
-    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg])
-    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
+    @config.expect.plugins.returns([:array, :cexception, :return_thru_ptr, :ignore_arg, :ignore])
     @config.expect.treat_as.returns({'int' => 'INT','short' => 'INT16','long' => 'INT','char' => 'INT8','uint32_t' => 'HEX32','char*' => 'STRING'})
     @cmock_generator_utils_complex = CMockGeneratorUtils.new(@config, {:unity_helper => @unity_helper, :A=>1, :B=>2})
   end
 
   def teardown
   end
-  
+
   should "have set up internal accessors correctly on init" do
     assert_equal(@config, @cmock_generator_utils_simple.config)
     assert_equal({:unity_helper => @unity_helper}, @cmock_generator_utils_simple.helpers)
     assert_equal(false,   @cmock_generator_utils_simple.arrays)
     assert_equal(false,   @cmock_generator_utils_simple.cexception)
   end
-  
+
   should "have set up internal accessors correctly on init, complete with passed helpers" do
     assert_equal(@config, @cmock_generator_utils_complex.config)
     assert_equal({:unity_helper => @unity_helper, :A=>1, :B=>2},@cmock_generator_utils_complex.helpers)
@@ -52,7 +56,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     assert_equal(true, @cmock_generator_utils_simple.ptr_or_str?('int*'))
     assert_equal(true, @cmock_generator_utils_simple.ptr_or_str?('char*'))
   end
-  
+
   should "add code for a base expectation with no plugins" do
     expected =
       "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
@@ -63,42 +67,44 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     output = @cmock_generator_utils_simple.code_add_base_expectation("Apple")
     assert_equal(expected, output)
   end
-        
+
   should "add code for a base expectation with all plugins" do
     expected =
       "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
       "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
       "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n" +
       "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
-      "  cmock_call_instance->LineNumber = cmock_line;\n" + 
+      "  Mock.Apple_IgnoreBool = (int)0;\n" +
+      "  cmock_call_instance->LineNumber = cmock_line;\n" +
       "  cmock_call_instance->CallOrder = ++GlobalExpectCount;\n" +
       "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n"
     output = @cmock_generator_utils_complex.code_add_base_expectation("Apple", true)
     assert_equal(expected, output)
   end
-        
+
   should "add code for a base expectation with all plugins and ordering not supported" do
     expected =
       "  CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_Apple_CALL_INSTANCE));\n" +
       "  CMOCK_Apple_CALL_INSTANCE* cmock_call_instance = (CMOCK_Apple_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);\n" +
       "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"CMock has run out of memory. Please allocate more.\");\n" +
       "  Mock.Apple_CallInstance = CMock_Guts_MemChain(Mock.Apple_CallInstance, cmock_guts_index);\n" +
+      "  Mock.Apple_IgnoreBool = (int)0;\n" +
       "  cmock_call_instance->LineNumber = cmock_line;\n" +
       "  cmock_call_instance->ExceptionToThrow = CEXCEPTION_NONE;\n"
     output = @cmock_generator_utils_complex.code_add_base_expectation("Apple", false)
     assert_equal(expected, output)
   end
-  
+
   should "add argument expectations for values when no array plugin" 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"
-    
+
     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"
 
@@ -107,23 +113,23 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     assert_equal(expected3, @cmock_generator_utils_simple.code_add_an_arg_expectation(arg3))
     assert_equal(expected4, @cmock_generator_utils_simple.code_add_an_arg_expectation(arg4))
   end
-  
+
   should "add argument expectations for values when array plugin enabled" do
     arg1 = { :name => "Orange", :const? => false, :type => 'int', :ptr? => false }
     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" +
                 "  cmock_call_instance->Expected_Lemon_Depth = Lemon_Depth;\n" +
                 "  cmock_call_instance->IgnoreArg_Lemon = 0;\n"
-    
+
     arg3 = { :name => "Kiwi", :const? => false, :type => 'KIWI_T*', :ptr? => true }
     expected3 = "  cmock_call_instance->Expected_Kiwi = Kiwi;\n" +
                 "  cmock_call_instance->Expected_Kiwi_Depth = Kiwi_Depth;\n" +
                 "  cmock_call_instance->IgnoreArg_Kiwi = 0;\n" +
                 "  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" +
                 "  cmock_call_instance->IgnoreArg_Lime = 0;\n"
@@ -133,19 +139,19 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     assert_equal(expected3, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg3, 'Lemon_Depth'))
     assert_equal(expected4, @cmock_generator_utils_complex.code_add_an_arg_expectation(arg4))
   end
-  
+
   should 'not have an argument loader when the function has no arguments' do
     function = { :name => "Melon", :args_string => "void" }
-     
+
     assert_equal("", @cmock_generator_utils_complex.code_add_argument_loader(function))
   end
-  
+
   should 'create an argument loader when the function has arguments' do
-    function = { :name => "Melon", 
+    function = { :name => "Melon",
                  :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{\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" +
@@ -154,11 +160,11 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
   end
 
   should 'create an argument loader when the function has arguments supporting arrays' do
-    function = { :name => "Melon", 
+    function = { :name => "Melon",
                  :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{\n" +
                "  cmock_call_instance->Expected_MyIntPtr = MyIntPtr;\n" +
                "  cmock_call_instance->Expected_MyIntPtr_Depth = MyIntPtr_Depth;\n" +
                "  cmock_call_instance->IgnoreArg_MyIntPtr = 0;\n" +
@@ -170,15 +176,15 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
                "}\n\n"
     assert_equal(expected, @cmock_generator_utils_complex.code_add_argument_loader(function))
   end
-  
+
   should "not call argument loader if there are no arguments to actually use for this function" do
     function = { :name => "Pineapple", :args_string => "void" }
-     
+
     assert_equal("", @cmock_generator_utils_complex.code_call_argument_loader(function))
   end
 
   should 'call an argument loader when the function has arguments' do
-    function = { :name => "Pineapple", 
+    function = { :name => "Pineapple",
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
@@ -187,14 +193,14 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
   end
 
   should 'call an argument loader when the function has arguments with arrays' do
-    function = { :name => "Pineapple", 
+    function = { :name => "Pineapple",
                  :args_string => "stuff",
                  :args => [test_arg[:int_ptr], test_arg[:mytype], test_arg[:string]]
     }
     expected = "  CMockExpectParameters_Pineapple(cmock_call_instance, MyIntPtr, 1, MyMyType, MyStr);\n"
     assert_equal(expected, @cmock_generator_utils_complex.code_call_argument_loader(function))
   end
-  
+
   should 'handle a simple assert when requested' do
     function = { :name => 'Pear' }
     arg      = test_arg[:int]
@@ -217,7 +223,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('char*').returns(['UNITY_TEST_ASSERT_EQUAL_STRING',''])
     assert_equal(expected, @cmock_generator_utils_simple.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle custom types as memory compares when we have no better way to do it' do
     function = { :name => 'Pear' }
     arg      = test_arg[:mytype]
@@ -233,7 +239,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('MY_TYPE').returns(['UNITY_TEST_ASSERT_EQUAL_MY_TYPE',''])
     assert_equal(expected, @cmock_generator_utils_simple.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle pointers to custom types with array handlers, even if the array extension is turned off' do
     function = { :name => 'Pear' }
     arg      = test_arg[:mytype]
@@ -249,7 +255,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('int').returns(['UNITY_TEST_ASSERT_EQUAL_INT',''])
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle an array comparison with array plugin enabled' do
     function = { :name => 'Pear' }
     arg      = test_arg[:int_ptr]
@@ -265,7 +271,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('int*').returns(['UNITY_TEST_ASSERT_EQUAL_INT_ARRAY',''])
    assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle const char as string compares with array plugin enabled' do
     function = { :name => 'Pear' }
     arg      = test_arg[:string]
@@ -273,15 +279,15 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('char*').returns(['UNITY_TEST_ASSERT_EQUAL_STRING',''])
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle custom types as memory compares when we have no better way to do it with array plugin enabled' do
     function = { :name => 'Pear' }
     arg      = test_arg[:mytype]
-    expected = "  if (!cmock_call_instance->IgnoreArg_MyMyType)\n  {\n    UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType), sizeof(MY_TYPE), cmock_line, \"Function 'Pear' called with unexpected value for argument 'MyMyType'.\");\n  }\n"
-    @unity_helper.expect.get_helper('MY_TYPE').returns(['UNITY_TEST_ASSERT_EQUAL_MEMORY','&'])
+    expected = "  if (!cmock_call_instance->IgnoreArg_MyMyType)\n  {\n    if (&cmock_call_instance->Expected_MyMyType == NULL)\n      { UNITY_TEST_ASSERT_NULL(MyMyType, cmock_line, \"Expected NULL. Function 'Pear' called with unexpected value for argument 'MyMyType'.\"); }\n    else\n      { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(&cmock_call_instance->Expected_MyMyType), (void*)(&MyMyType), sizeof(MY_TYPE), 1, cmock_line, \"Function 'Pear' called with unexpected value for argument 'MyMyType'.\"); }\n  }\n"
+    @unity_helper.expect.get_helper('MY_TYPE').returns(['UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY','&'])
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle custom types with custom handlers when available, even if they do not support the extra message with array plugin enabled' do
     function = { :name => 'Pear' }
     arg      = test_arg[:mytype]
@@ -305,7 +311,7 @@ class CMockGeneratorUtilsTest < Test::Unit::TestCase
     @unity_helper.expect.get_helper('MY_TYPE*').returns(['UNITY_TEST_ASSERT_EQUAL_MY_TYPE_ARRAY',''])
     assert_equal(expected, @cmock_generator_utils_complex.code_verify_an_arg_expectation(function, arg))
   end
-  
+
   should 'handle custom types with array handlers when array plugin is enabled for non-array types' do
     function = { :name => 'Pear' }
     arg      = test_arg[:mytype]