ceedling 0.0.2 → 0.0.3

data/new_project_template/vendor/ceedling/vendor/cmock/test/unit/cmock_generator_plugin_array_test.rb

@@ -1,114 +0,0 @@
-# ==========================================
-#   CMock Project - Automatic Mock Generation for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
-
-require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
-require 'cmock_generator_plugin_array'
-
-class CMockGeneratorPluginArrayTest < Test::Unit::TestCase
-  def setup
-    create_mocks :config, :utils
-    
-    #no strict ordering
-    @config.expect.when_ptr.returns(:compare_data)
-    @config.expect.enforce_strict_ordering.returns(false)
-    @config.stubs!(:respond_to?).returns(true)
-    @utils.expect.helpers.returns({})
-    @cmock_generator_plugin_array = CMockGeneratorPluginArray.new(@config, @utils)
-  end
-
-  def teardown
-  end
-  
-  should "have set up internal accessors correctly on init" do
-    assert_equal(@config, @cmock_generator_plugin_array.config)
-    assert_equal(@utils,  @cmock_generator_plugin_array.utils)
-    assert_equal(nil,     @cmock_generator_plugin_array.unity_helper)
-    assert_equal(8,       @cmock_generator_plugin_array.priority)
-  end
-  
-  should "not include any additional include files" do 
-    assert(!@cmock_generator_plugin_array.respond_to?(:include_files))
-  end
-  
-  should "not add to typedef structure for functions of style 'int* func(void)'" do
-    function = {:name => "Oak", :args => [], :return => test_return[:int_ptr]}
-    returned = @cmock_generator_plugin_array.instance_typedefs(function)
-    assert_equal("", returned)
-  end
-  
-  should "add to tyepdef structure mock needs of functions of style 'void func(int chicken, int* pork)'" do
-    function = {:name => "Cedar", :args => [{ :name => "chicken", :type => "int", :ptr? => false}, { :name => "pork", :type => "int*", :ptr? => true}], :return => test_return[:void]}
-    expected = "  int Expected_pork_Depth;\n"
-    returned = @cmock_generator_plugin_array.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "not add an additional mock interface for functions not containing pointers" do
-    function = {:name => "Maple", :args_string => "int blah", :return  => test_return[:string], :contains_ptr? => false}
-    returned = @cmock_generator_plugin_array.mock_function_declarations(function)
-    assert_nil(returned)
-  end
-  
-  should "add another mock function declaration for functions of style 'void func(int* tofu)'" do
-    function = {:name => "Pine", 
-                :args => [{ :type => "int*",
-                           :name => "tofu",
-                           :ptr? => true,
-                         }],
-                :return => test_return[:void], 
-                :contains_ptr? => true }
-    
-    expected = "#define #{function[:name]}_ExpectWithArray(tofu, tofu_Depth) #{function[:name]}_CMockExpectWithArray(__LINE__, tofu, tofu_Depth)\n" +
-               "void #{function[:name]}_CMockExpectWithArray(UNITY_LINE_TYPE cmock_line, int* tofu, int tofu_Depth);\n"
-    returned = @cmock_generator_plugin_array.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add another mock function declaration for functions of style 'const char* func(int* tofu)'" do
-    function = {:name => "Pine", 
-                :args => [{ :type => "int*",
-                           :name => "tofu",
-                           :ptr? => true,
-                         }],
-                :return => test_return[:string],
-                :contains_ptr? => true }
-    
-    expected = "#define #{function[:name]}_ExpectWithArrayAndReturn(tofu, tofu_Depth, cmock_retval) #{function[:name]}_CMockExpectWithArrayAndReturn(__LINE__, tofu, tofu_Depth, cmock_retval)\n" +
-               "void #{function[:name]}_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, int* tofu, int tofu_Depth, const char* cmock_to_return);\n"
-    returned = @cmock_generator_plugin_array.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "not have a mock function implementation" do
-    assert(!@cmock_generator_plugin_array.respond_to?(:mock_implementation))
-  end
-
-  should "not have a mock interfaces for functions of style 'int* func(void)'" do
-    function = {:name => "Pear", :args => [], :args_string => "void", :return => test_return[:int_ptr]}
-    returned = @cmock_generator_plugin_array.mock_interfaces(function)
-    assert_nil(returned)
-  end
-  
-  should "add mock interfaces for functions of style 'int* func(int* pescado, int pes)'" do
-    function = {:name => "Lemon", 
-                :args => [{ :type => "int*", :name => "pescado", :ptr? => true}, { :type => "int", :name => "pes", :ptr? => false}], 
-                :args_string => "int* pescado, int pes", 
-                :return  => test_return[:int_ptr], 
-                :contains_ptr? => true }
-    @utils.expect.code_add_base_expectation("Lemon").returns("mock_retval_0")
-    
-    expected = ["void Lemon_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, int* pescado, int pescado_Depth, int pes, int* cmock_to_return)\n",
-                "{\n",
-                "mock_retval_0",
-                "  CMockExpectParameters_Lemon(cmock_call_instance, pescado, pescado_Depth, pes);\n",
-                "  cmock_call_instance->ReturnVal = cmock_to_return;\n",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_array.mock_interfaces(function).join
-    assert_equal(expected, returned)
-  end
-  
-end

data/new_project_template/vendor/ceedling/vendor/cmock/test/unit/cmock_generator_plugin_callback_test.rb

@@ -1,190 +0,0 @@
-# ==========================================
-#   CMock Project - Automatic Mock Generation for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
-
-require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
-require 'cmock_generator_plugin_callback'
-
-class CMockGeneratorPluginCallbackTest < Test::Unit::TestCase
-  def setup
-    create_mocks :config, :utils
-    
-    @config.expect.callback_include_count.returns(true)
-    @config.expect.callback_after_arg_check.returns(false)
-  
-    @cmock_generator_plugin_callback = CMockGeneratorPluginCallback.new(@config, @utils)
-  end
-
-  def teardown
-  end
-  
-  should "have set up internal accessors correctly on init" do
-    assert_equal(@config, @cmock_generator_plugin_callback.config)
-    assert_equal(@utils,  @cmock_generator_plugin_callback.utils)
-    assert_equal(6,       @cmock_generator_plugin_callback.priority)
-  end
-  
-  should "not include any additional include files" do 
-    assert(!@cmock_generator_plugin_callback.respond_to?(:include_files))
-  end
-  
-  should "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" +
-               "  int Oak_CallbackCalls;\n"
-    returned = @cmock_generator_plugin_callback.instance_structure(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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
-    returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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
-    @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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
-    returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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
-    returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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
-    @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions of style 'void func(void)'" do
-    function = {:name => "Apple", :args => [], :args_string => "void", :return => test_return[:void]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
-                "  {\n",
-                "    Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
-                "    return;\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions 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",
-                "  {\n",
-                "    Mock.Apple_CallbackFunctionPointer();\n",
-                "    return;\n",
-                "  }\n"
-               ].join
-    @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions of style 'int func(void)'" do
-    function = {:name => "Apple", :args => [], :args_string => "void", :return => test_return[:int]}
-    expected = ["  if (Mock.Apple_CallbackFunctionPointer != NULL)\n",
-                "  {\n",
-                "    return Mock.Apple_CallbackFunctionPointer(Mock.Apple_CallbackCalls++);\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions of style 'void func(int* steak, uint8_t flag)'" do
-    function = {:name => "Apple", 
-                :args => [ { :type => 'int*', :name => 'steak', :ptr? => true},
-                  { :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",
-                "  {\n",
-                "    Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
-                "    return;\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions of style 'void func(int* steak, uint8_t flag)' when count turned off" do
-    function = {:name => "Apple", 
-                :args => [ { :type => 'int*', :name => 'steak', :ptr? => true},
-                  { :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",
-                "  {\n",
-                "    Mock.Apple_CallbackFunctionPointer(steak, flag);\n",
-                "    return;\n",
-                "  }\n"
-               ].join
-    @cmock_generator_plugin_callback.include_count = false
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-
-  should "add mock function implementation for functions of style 'int16_t func(int* steak, uint8_t flag)'" do
-    function = {:name => "Apple", 
-                :args => [ { :type => 'int*', :name => 'steak', :ptr? => true},
-                  { :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",
-                "  {\n",
-                "    return Mock.Apple_CallbackFunctionPointer(steak, flag, Mock.Apple_CallbackCalls++);\n",
-                "  }\n"
-               ].join
-    returned = @cmock_generator_plugin_callback.mock_implementation_precheck(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock interfaces for functions " do
-    function = {:name => "Lemon", 
-                :args => [{ :type => "char*", :name => "pescado"}], 
-                :args_string => "char* pescado",
-                :return => test_return[:int]
-               }
-     
-    expected = ["void Lemon_StubWithCallback(CMOCK_Lemon_CALLBACK Callback)\n",
-                "{\n",
-                "  Mock.Lemon_CallbackFunctionPointer = Callback;\n",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_callback.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-
-  should "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

data/new_project_template/vendor/ceedling/vendor/cmock/test/unit/cmock_generator_plugin_cexception_test.rb

@@ -1,94 +0,0 @@
-# ==========================================
-#   CMock Project - Automatic Mock Generation for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
-
-require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
-require 'cmock_generator_plugin_cexception'
-
-class CMockGeneratorPluginCexceptionTest < Test::Unit::TestCase
-  def setup
-    create_mocks :config, :utils
-    @cmock_generator_plugin_cexception = CMockGeneratorPluginCexception.new(@config, @utils)
-  end
-
-  def teardown
-  end
-  
-  should "have set up internal accessors correctly on init" do
-    assert_equal(@config, @cmock_generator_plugin_cexception.config)
-    assert_equal(@utils,  @cmock_generator_plugin_cexception.utils)
-    assert_equal(7,       @cmock_generator_plugin_cexception.priority)
-  end
-  
-  should "include the cexception library" do 
-    expected = "#include \"CException.h\"\n"
-    returned = @cmock_generator_plugin_cexception.include_files
-    assert_equal(expected, returned)
-  end
-  
-  should "add to typedef structure mock needs" do
-    function = { :name => "Oak", :args => [], :return => test_return[:void] }
-    expected = "  CEXCEPTION_T ExceptionToThrow;\n"
-    returned = @cmock_generator_plugin_cexception.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function declarations for functions without arguments" do
-    function = { :name => "Spruce", :args_string => "void", :return => test_return[:void] }
-    expected = "#define Spruce_ExpectAndThrow(cmock_to_throw) Spruce_CMockExpectAndThrow(__LINE__, cmock_to_throw)\n"+
-               "void Spruce_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, CEXCEPTION_T cmock_to_throw);\n"
-    returned = @cmock_generator_plugin_cexception.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function declarations for functions with arguments" do
-    function = { :name => "Spruce", :args_string => "const char* Petunia, uint32_t Lily", :args_call => "Petunia, Lily", :return  => test_return[:void] }
-    expected = "#define Spruce_ExpectAndThrow(Petunia, Lily, cmock_to_throw) Spruce_CMockExpectAndThrow(__LINE__, Petunia, Lily, cmock_to_throw)\n" +
-               "void Spruce_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, const char* Petunia, uint32_t Lily, CEXCEPTION_T cmock_to_throw);\n"
-    returned = @cmock_generator_plugin_cexception.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add a mock implementation" do
-    function = {:name => "Cherry", :args => [], :return => test_return[:void]}
-    expected = "  if (cmock_call_instance->ExceptionToThrow != CEXCEPTION_NONE)\n  {\n" + 
-               "    Throw(cmock_call_instance->ExceptionToThrow);\n  }\n"
-    returned = @cmock_generator_plugin_cexception.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock interfaces for functions without arguments" do
-    function = {:name => "Pear", :args_string => "void", :args => [], :return  => test_return[:void]}
-    @utils.expect.code_add_base_expectation("Pear").returns("mock_retval_0")
-    @utils.expect.code_call_argument_loader(function).returns("")
-  
-    expected = ["void Pear_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, CEXCEPTION_T cmock_to_throw)\n",
-                "{\n",
-                "mock_retval_0",
-                "",
-                "  cmock_call_instance->ExceptionToThrow = cmock_to_throw;\n",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_cexception.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add a mock interfaces for functions with arguments" do
-    function = {:name => "Pear", :args_string => "int blah", :args => [{ :type => "int", :name => "blah" }], :return  => test_return[:void]}
-    @utils.expect.code_add_base_expectation("Pear").returns("mock_retval_0")
-    @utils.expect.code_call_argument_loader(function).returns("mock_return_1")
-    
-    expected = ["void Pear_CMockExpectAndThrow(UNITY_LINE_TYPE cmock_line, int blah, CEXCEPTION_T cmock_to_throw)\n",
-                "{\n",
-                "mock_retval_0",
-                "mock_return_1",
-                "  cmock_call_instance->ExceptionToThrow = cmock_to_throw;\n",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_cexception.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-end

data/new_project_template/vendor/ceedling/vendor/cmock/test/unit/cmock_generator_plugin_expect_test.rb

@@ -1,206 +0,0 @@
-# ==========================================
-#   CMock Project - Automatic Mock Generation for C
-#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-#   [Released under MIT License. Please refer to license.txt for details]
-# ========================================== 
-
-require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
-require 'cmock_generator_plugin_expect'
-
-class CMockGeneratorPluginExpectTest < Test::Unit::TestCase
-  def setup
-    create_mocks :config, :utils
-    
-    #no strict ordering and args_and_calls
-    @config.expect.when_ptr.returns(:compare_data)
-    @config.expect.enforce_strict_ordering.returns(false)
-    @config.stubs!(:respond_to?).returns(true)
-    # @config.expect.ignore.returns(:args_and_calls)
-    @utils.expect.helpers.returns({})
-    @cmock_generator_plugin_expect = CMockGeneratorPluginExpect.new(@config, @utils)
-    
-    #strict ordering and args_only
-    @config.expect.when_ptr.returns(:compare_data)
-    @config.expect.enforce_strict_ordering.returns(true)
-    @config.stubs!(:respond_to?).returns(true)
-    # @config.expect.ignore.returns(:args_only)
-    @utils.expect.helpers.returns({})
-    @cmock_generator_plugin_expect_strict = CMockGeneratorPluginExpect.new(@config, @utils)
-  end
-
-  def teardown
-  end
-  
-  should "have set up internal accessors correctly on init" do
-    assert_equal(@config, @cmock_generator_plugin_expect.config)
-    assert_equal(@utils,  @cmock_generator_plugin_expect.utils)
-    assert_equal(nil,     @cmock_generator_plugin_expect.unity_helper)
-    assert_equal(5,       @cmock_generator_plugin_expect.priority)
-  end
-  
-  should "not include any additional include files" do 
-    assert(!@cmock_generator_plugin_expect.respond_to?(:include_files))
-  end
-  
-  should "add to typedef structure mock needs of functions of style 'void func(void)'" do
-    function = {:name => "Oak", :args => [], :return => test_return[:void]}
-    expected = ""
-    returned = @cmock_generator_plugin_expect.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add to typedef structure mock needs of functions of style 'int func(void)'" do
-    function = {:name => "Elm", :args => [], :return => test_return[:int]}
-    expected = "  int ReturnVal;\n"
-    returned = @cmock_generator_plugin_expect.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add to typedef structure mock needs of functions of style 'void func(int chicken, char* pork)'" do
-    function = {:name => "Cedar", :args => [{ :name => "chicken", :type => "int"}, { :name => "pork", :type => "char*"}], :return => test_return[:void]}
-    expected = "  int Expected_chicken;\n  char* Expected_pork;\n"
-    returned = @cmock_generator_plugin_expect.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add to typedef structure mock needs of functions of style 'int func(float beef)'" do
-    function = {:name => "Birch", :args => [{ :name => "beef", :type => "float"}], :return => test_return[:int]}
-    expected = "  int ReturnVal;\n  float Expected_beef;\n"
-    returned = @cmock_generator_plugin_expect.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add to typedef structure mock needs of functions of style 'void func(void)' and global ordering" do
-    function = {:name => "Oak", :args => [], :return => test_return[:void]}
-    expected = "  int CallOrder;\n"
-    returned = @cmock_generator_plugin_expect_strict.instance_typedefs(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function declaration for functions of style 'void func(void)'" do
-    function = {:name => "Maple", :args => [], :return => test_return[:void]}
-    expected = "#define Maple_Expect() Maple_CMockExpect(__LINE__)\n" +
-               "void Maple_CMockExpect(UNITY_LINE_TYPE cmock_line);\n"
-    returned = @cmock_generator_plugin_expect.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function declaration for functions of style 'int func(void)'" do
-    function = {:name => "Spruce", :args => [], :return => test_return[:int]}
-    expected = "#define Spruce_ExpectAndReturn(cmock_retval) Spruce_CMockExpectAndReturn(__LINE__, cmock_retval)\n" +
-               "void Spruce_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return);\n"
-    returned = @cmock_generator_plugin_expect.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function declaration for functions of style 'const char* func(int tofu)'" do
-    function = {:name => "Pine", :args => ["int tofu"], :args_string => "int tofu", :args_call => 'tofu', :return => test_return[:string]}
-    expected = "#define Pine_ExpectAndReturn(tofu, cmock_retval) Pine_CMockExpectAndReturn(__LINE__, tofu, cmock_retval)\n" +
-               "void Pine_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int tofu, const char* cmock_to_return);\n"
-    returned = @cmock_generator_plugin_expect.mock_function_declarations(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function implementation for functions of style 'void func(void)'" do
-    function = {:name => "Apple", :args => [], :return => test_return[:void]}
-    expected = ""
-    returned = @cmock_generator_plugin_expect.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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(function, function[:args][0]).returns(" mocked_retval_1")
-    @utils.expect.code_verify_an_arg_expectation(function, function[:args][1]).returns(" mocked_retval_2")
-    expected = " mocked_retval_1 mocked_retval_2"
-    returned = @cmock_generator_plugin_expect.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock function implementation using ordering if needed" do
-    function = {:name => "Apple", :args => [], :return => test_return[:void]}
-    expected = ""
-    @cmock_generator_plugin_expect.ordered = true
-    returned = @cmock_generator_plugin_expect.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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(function, function[:args][0]).returns("mocked_retval_0")
-    expected = "mocked_retval_0"
-    @cmock_generator_plugin_expect.ordered = true
-    returned = @cmock_generator_plugin_expect_strict.mock_implementation(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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("Pear").returns("mock_retval_0 ")
-    @utils.expect.code_call_argument_loader(function).returns("mock_retval_1 ")
-    expected = ["void Pear_CMockExpect(UNITY_LINE_TYPE cmock_line)\n",
-                "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_expect.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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("Orange").returns("mock_retval_0 ")
-    @utils.expect.code_call_argument_loader(function).returns("mock_retval_1 ")
-    @utils.expect.code_assign_argument_quickly("cmock_call_instance->ReturnVal", function[:return]).returns("mock_retval_2")
-    expected = ["void Orange_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)\n",
-                "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "mock_retval_2",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_expect.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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("Lemon").returns("mock_retval_0 ")
-    @utils.expect.code_call_argument_loader(function).returns("mock_retval_1 ")
-    @utils.expect.code_assign_argument_quickly("cmock_call_instance->ReturnVal", function[:return]).returns("mock_retval_2")
-    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",
-                "}\n\n"
-               ].join
-    returned = @cmock_generator_plugin_expect.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "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("Pear").returns("mock_retval_0 ")
-    @utils.expect.code_call_argument_loader(function).returns("mock_retval_1 ")
-    expected = ["void Pear_CMockExpect(UNITY_LINE_TYPE cmock_line)\n",
-                "{\n",
-                "mock_retval_0 ",
-                "mock_retval_1 ",
-                "}\n\n"
-               ].join
-    @cmock_generator_plugin_expect.ordered = true
-    returned = @cmock_generator_plugin_expect.mock_interfaces(function)
-    assert_equal(expected, returned)
-  end
-  
-  should "add mock verify lines" do
-    function = {:name => "Banana" }
-    expected = "  UNITY_TEST_ASSERT(CMOCK_GUTS_NONE == Mock.Banana_CallInstance, cmock_line, \"Function 'Banana' called less times than expected.\");\n"
-    returned = @cmock_generator_plugin_expect.mock_verify(function)
-    assert_equal(expected, returned)
-  end
-  
-end