ceedling 0.13.0.rc1 → 0.13.0

data/vendor/cmock/test/system/test_interactions/unity_64bit_support.yml

@@ -0,0 +1,77 @@
+---
+#The purpose of this test is to play with things 64-bit integers, which aren't supported by all compilers
+:cmock:
+  :plugins:
+  - :array
+  - :ignore
+
+:systest:
+  :types: |
+    #include "unity_internals.h"
+    typedef _UU64 TEST64;
+    
+  :mockable: |
+    TEST64 foo(TEST64 a);
+    TEST64* bar(TEST64* b);
+
+  :source: 
+    :header: |   
+      TEST64 function_a(void);
+
+    :code: |
+      TEST64 function_a(void) {
+        TEST64 a = 0x1234567890123456;
+        TEST64 b;
+        TEST64* c;
+        
+        b = foo(a);
+        c = bar(&b);
+        return *c;
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: TRUE
+      :should: 'handle a straightforward 64-bit series of calls'
+      :code: |
+        test()
+        {
+          TEST64 a = 0x0987654321543210;
+          TEST64 b = 0x5a5a5a5a5a5a5a5a;
+          foo_ExpectAndReturn(0x1234567890123456, 0x0987654321543210);
+          bar_ExpectAndReturn(&a, &b);
+          
+          TEST_ASSERT_EQUAL_HEX64(b, function_a());
+        }
+        
+    - :pass: FALSE
+      :should: 'handle a straightforward 64-bit series of calls with a failure'
+      :code: |
+        test()
+        {
+          TEST64 a = 0x0987654321543210;
+          TEST64 b = 0x5a5a5a5a5a5a5a5a;
+          foo_ExpectAndReturn(0x1234567890123456, 0x0987654321543211);
+          bar_ExpectAndReturn(&a, &b);
+          
+          TEST_ASSERT_EQUAL_HEX64(b, function_a());
+        }
+        
+    - :pass: FALSE
+      :should: 'handle a straightforward 64-bit series of calls returning a failure'
+      :code: |
+        test()
+        {
+          TEST64 a = 0x0987654321543210;
+          TEST64 b = 0x5a5a5a5a5a5a5a5a;
+          foo_ExpectAndReturn(0x1234567890123456, 0x0987654321543210);
+          bar_ExpectAndReturn(&a, &b);
+          
+          TEST_ASSERT_EQUAL_HEX64(b+1, function_a());
+        }
+        
+...

data/vendor/cmock/test/system/test_interactions/unity_ignores.yml

@@ -0,0 +1,139 @@
+---
+:cmock:
+  :plugins:
+  - # none
+
+:systest:
+  :types: |
+    #define UINT32 unsigned int
+
+  :mockable: |
+    UINT32 foo(UINT32 a);
+    void bar(void);
+
+  :source: 
+    :header: |    
+      UINT32 function_a(int a);
+      void function_b(void);
+
+    :code: |
+      UINT32 function_a(int a)    
+      {
+        bar();
+        return foo((UINT32)a);
+      }    
+
+      void function_b(void) 
+      {
+        bar();
+      }
+      
+  :tests:
+    :common: |
+      void setUp(void) {}
+      void tearDown(void) {}
+      
+    :units:
+    - :pass: :ignore
+      :should: 'ignore incorrect expects after the TEST_IGNORE call'
+      :code: |
+        test()
+        {
+          TEST_IGNORE();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(40, function_a(30));
+        }
+      
+    - :pass: :ignore
+      :should: 'ignore missing expects after the TEST_IGNORE call'
+      :code: |
+        test()
+        {
+          TEST_IGNORE();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(20, function_a(10));
+        }
+      
+    - :pass: :ignore
+      :should: 'ignore extra expects after the TEST_IGNORE call'
+      :code: |
+        test()
+        {
+          TEST_IGNORE();
+          bar_Expect();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          foo_ExpectAndReturn(10, 20);
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(20, function_a(10));
+        }
+      
+    - :pass: :ignore
+      :should: 'ignore no expects after the TEST_IGNORE call'
+      :code: |
+        test()
+        {
+          TEST_IGNORE();
+          TEST_ASSERT_EQUAL(20, function_a(10));
+        }
+        
+    - :pass: :ignore
+      :should: 'ignore extra expects after the TEST_IGNORE call even if it happens later'
+      :code: |
+        test()
+        {
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          function_a(10);
+          
+          TEST_IGNORE();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(40, function_a(30));
+        }
+        
+    - :pass: false
+      :should: 'still fail if there are expect problems before the TEST_IGNORE'
+      :code: |
+        test()
+        {
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          function_a(30);
+          
+          TEST_IGNORE();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(40, function_a(30));
+        }
+        
+    - :pass: false
+      :should: 'still fail if there are missing expect problems before the TEST_IGNORE'
+      :code: |
+        test()
+        {
+          bar_Expect();
+          function_a(10);
+          
+          TEST_IGNORE();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(40, function_a(30));
+        }
+        
+    - :pass: :ignore
+      :should: 'ignore if extra expects before the TEST_IGNORE because it ignored the rest of the test that might have made calls to it'
+      :code: |
+        test()
+        {
+          bar_Expect();
+          bar_Expect();
+          foo_ExpectAndReturn(10, 20);
+          function_a(10);
+          
+          TEST_IGNORE();
+          foo_ExpectAndReturn(10, 20);
+          TEST_ASSERT_EQUAL(40, function_a(30));
+        }
+...

data/vendor/cmock/test/test_helper.rb

@@ -0,0 +1,44 @@
+# ==========================================
+#   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]
+# ========================================== 
+[ "/../config/test_environment",
+  "/../vendor/behaviors/lib/behaviors"
+].each do |req|
+  require File.expand_path(File.dirname(__FILE__)) + req
+end
+
+#gem install test-unit -v 1.2.3
+ruby_version = RUBY_VERSION.split('.')
+if (ruby_version[1].to_i == 9) and (ruby_version[2].to_i > 1)
+  require 'rubygems'
+  gem 'test-unit'
+end
+require 'test/unit'
+require 'hardmock'
+
+class Test::Unit::TestCase
+  extend Behaviors
+  
+  #these are helpful test structures which can be used during tests
+  
+  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'},
+    }
+  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},
+    }
+  end
+end

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

@@ -0,0 +1,121 @@
+# ==========================================
+#   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_config'
+
+class CMockConfigTest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+  
+  should "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_equal(CMockConfig::CMockDefaultOptions[:attributes],            config.attributes)
+    assert_equal(CMockConfig::CMockDefaultOptions[:plugins],               config.plugins)
+    assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs],         config.treat_externs)
+  end
+  
+  should "replace only options specified in a hash" do
+    test_includes = ['hello']
+    test_attributes = ['blah', 'bleh']
+    config = CMockConfig.new(:includes => test_includes, :attributes => test_attributes)
+    assert_equal(CMockConfig::CMockDefaultOptions[:mock_path],              config.mock_path)
+    assert_equal(test_includes,                                             config.includes)
+    assert_equal(test_attributes,                                           config.attributes)
+    assert_equal(CMockConfig::CMockDefaultOptions[:plugins],                config.plugins)
+    assert_equal(CMockConfig::CMockDefaultOptions[:treat_externs],          config.treat_externs)
+  end
+  
+  should "replace only options specified in a yaml file" 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_equal(test_plugins,                                              config.plugins)
+    assert_equal(:include,                                                  config.treat_externs)
+  end
+
+  should "populate treat_as map with internal standard_treat_as_map defaults, redefine defaults, and add custom values" do
+  
+    user_treat_as1 = {
+      'BOOL'          => 'UINT8', # redefine standard default
+      'unsigned long' => 'INT',   # redefine standard default
+      'U8'            => 'UINT8', # custom value
+      'U16'           => 'UINT16' # custom value
+    }
+    user_treat_as2 = {
+      'BOOL'          => 'INT16', # redefine standard default
+      'U16'           => 'HEX16'  # custom value
+    }
+ 
+    config1 = CMockConfig.new({:treat_as => user_treat_as1})
+    config2 = CMockConfig.new({:treat_as => user_treat_as2})
+    
+    # ----- USER SET 1
+    # standard defaults
+    assert_equal('INT',      config1.treat_as['BOOL_T'])
+    assert_equal('HEX32',    config1.treat_as['unsigned int'])
+    assert_equal('PTR',      config1.treat_as['void*'])
+    assert_equal('STRING',   config1.treat_as['CSTRING'])
+    assert_equal('STRING',   config1.treat_as['char*'])
+    assert_equal('HEX8',     config1.treat_as['unsigned char'])
+    assert_equal('INT',      config1.treat_as['long'])
+    assert_equal('INT16',    config1.treat_as['short'])
+
+    # overrides
+    assert_equal('UINT8',    config1.treat_as['BOOL'])
+    assert_equal('INT',      config1.treat_as['unsigned long'])
+    
+    # added custom values
+    assert_equal('UINT8',    config1.treat_as['U8'])
+    assert_equal('UINT16',   config1.treat_as['U16'])
+    
+    # standard_treat_as_map: unchanged
+    assert_equal('INT',      config1.standard_treat_as_map['BOOL'])
+    assert_equal('HEX32',    config1.standard_treat_as_map['unsigned long'])    
+    assert_equal('STRING',   config1.standard_treat_as_map['char*'])
+    
+    # ----- USER SET 2
+    # standard defaults
+    assert_equal('INT',      config2.treat_as['BOOL_T'])
+    assert_equal('HEX32',    config2.treat_as['unsigned int'])
+    assert_equal('PTR',      config2.treat_as['void*'])
+    assert_equal('STRING',   config2.treat_as['CSTRING'])
+    assert_equal('STRING',   config2.treat_as['char*'])
+    assert_equal('HEX8',     config2.treat_as['unsigned char'])
+    assert_equal('INT',      config2.treat_as['long'])
+    assert_equal('INT16',    config2.treat_as['short'])
+    assert_equal('HEX32',    config2.treat_as['unsigned long'])
+
+    # overrides
+    assert_equal('INT16',    config2.treat_as['BOOL'])
+    
+    # added custom values
+    assert_equal('HEX16',    config2.treat_as['U16'])
+    
+    # standard_treat_as_map: unchanged
+    assert_equal('INT',      config2.standard_treat_as_map['BOOL'])
+    assert_equal('HEX32',    config2.standard_treat_as_map['unsigned long'])    
+    assert_equal('STRING',   config2.standard_treat_as_map['char*'])
+  end
+  
+  should "standard treat_as map should be incorruptable" do
+    config = CMockConfig.new({})
+    
+    assert_equal('INT', config.standard_treat_as_map['BOOL_T'])
+    
+    local = config.standard_treat_as_map
+    local['BOOL_T'] = "U8"
+    
+    assert_equal('INT', config.standard_treat_as_map['BOOL_T'])
+  end
+  
+end

data/vendor/cmock/test/unit/cmock_config_test.yml

@@ -0,0 +1,5 @@
+:cmock:
+  :plugins:
+    - 'soda'
+    - 'pizza'
+  :treat_externs: :include

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

@@ -0,0 +1,30 @@
+# ==========================================
+#   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_file_writer'
+
+class CMockFileWriterTest < Test::Unit::TestCase
+  def setup
+    create_mocks :config
+    @cmock_file_writer = CMockFileWriter.new(@config)
+  end
+
+  def teardown
+  end
+  
+  should "have set up internal accessors correctly on init" do
+    assert_equal(@config, @cmock_file_writer.config)
+  end
+  
+  should "complain if a block was not specified when calling create" do
+    begin
+      @cmock_file_writer.create_file("test.txt")
+      assert false, "Should Have Thrown An Error When Calling Without A Block"
+    rescue
+    end
+  end  
+end

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

@@ -0,0 +1,413 @@
+# ==========================================
+#   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]
+# ========================================== 
+
+$ThisIsOnlyATest = true
+
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'cmock_generator'
+
+class MockedPluginHelper
+  def initialize return_this
+    @return_this = return_this
+  end
+  
+  def include_files
+    return @return_this
+  end
+  
+  def instance_structure( name, args, rettype )
+    return "  #{@return_this}_#{name}(#{args}, #{rettype})"
+  end
+  
+  def mock_verify( name )
+    return "  #{@return_this}_#{name}"
+  end
+  
+  def mock_destroy( name, args, rettype )
+    return "  #{@return_this}_#{name}(#{args}, #{rettype})"
+  end
+  
+  def mock_implementation(name, args)
+    return "  Mock#{name}#{@return_this}(#{args.join(", ")})"
+  end
+end
+
+class CMockGeneratorTest < Test::Unit::TestCase
+  def setup
+    create_mocks :config, :file_writer, :utils, :plugins
+    @module_name = "PoutPoutFish"
+    
+    #no strict handling
+    @config.expect.mock_prefix.returns("Mock")
+    @config.expect.enforce_strict_ordering.returns(nil)
+    @config.expect.framework.returns(:unity)
+    @config.expect.includes.returns(["ConfigRequiredHeader1.h","ConfigRequiredHeader2.h"])
+    #@config.expect.includes_h_pre_orig_header.returns(nil) #not called because includes called
+    @config.expect.includes_h_post_orig_header.returns(nil)
+    @config.expect.includes_c_pre_header.returns(nil)
+    @config.expect.includes_c_post_header.returns(nil)
+    @cmock_generator = CMockGenerator.new(@config, @file_writer, @utils, @plugins)
+    @cmock_generator.module_name = @module_name
+    @cmock_generator.mock_name = "Mock#{@module_name}"
+    
+    #strict handling
+    @config.expect.mock_prefix.returns("Mock")
+    @config.expect.enforce_strict_ordering.returns(true)
+    @config.expect.framework.returns(:unity)
+    @config.expect.includes.returns(nil)
+    @config.expect.includes_h_pre_orig_header.returns(nil)
+    @config.expect.includes_h_post_orig_header.returns(nil)
+    @config.expect.includes_c_pre_header.returns(nil)
+    @config.expect.includes_c_post_header.returns(nil)
+    @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}"
+  end
+
+  def teardown
+  end
+  
+  should "have set up internal accessors correctly on init" do
+    assert_equal(@config,       @cmock_generator.config)
+    assert_equal(@file_writer,  @cmock_generator.file_writer)
+    assert_equal(@utils,        @cmock_generator.utils)
+    assert_equal(@plugins,      @cmock_generator.plugins)
+  end
+  
+  should "create the top of a header file with optional include files from config and include file from plugin" do
+    @config.expect.mock_prefix.returns("Mock")
+    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 \"ConfigRequiredHeader1.h\"\n",
+                 "#include \"ConfigRequiredHeader2.h\"\n",
+                 "#include \"#{orig_filename}\"\n",
+                 "#include \"PluginRequiredHeader.h\"\n",
+                 "\n"
+               ]
+
+    @plugins.expect.run(:include_files).returns("#include \"PluginRequiredHeader.h\"\n")
+    
+    @cmock_generator.create_mock_header_header(output, "MockPoutPoutFish.h")
+    
+    assert_equal(expected, output)
+  end
+
+  should "create the top of a header file with optional include files from config" do
+    @config.expect.mock_prefix.returns("Mock")
+    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 \"ConfigRequiredHeader1.h\"\n",
+                 "#include \"ConfigRequiredHeader2.h\"\n",
+                 "#include \"#{orig_filename}\"\n",
+                 "\n"
+               ]
+
+    @plugins.expect.run(:include_files).returns('')
+    
+    @cmock_generator.create_mock_header_header(output, "MockPoutPoutFish.h")
+    
+    assert_equal(expected, output)
+  end
+
+  should "create the top of a header file with include file from plugin" do
+    @config.expect.mock_prefix.returns("Mock")
+    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 \"ConfigRequiredHeader1.h\"\n",
+                 "#include \"ConfigRequiredHeader2.h\"\n",
+                 "#include \"#{orig_filename}\"\n",
+                 "#include \"PluginRequiredHeader.h\"\n",
+                 "\n"
+               ]
+
+    @plugins.expect.run(:include_files).returns("#include \"PluginRequiredHeader.h\"\n")
+    
+    @cmock_generator.create_mock_header_header(output, "MockPoutPoutFish.h")
+    
+    assert_equal(expected, output)
+  end
+
+  should "write typedefs" do
+    typedefs = [ 'typedef unsigned char U8;', 
+                 'typedef char S8;',
+                 'typedef unsigned long U32;'
+                ]
+    output = []
+    expected = [ "\n",
+                 "typedef unsigned char U8;\n",
+                 "typedef char S8;\n",
+                 "typedef unsigned long U32;\n",
+                 "\n\n"
+               ]
+    
+    @cmock_generator.create_typedefs(output, typedefs)
+    
+    assert_equal(expected, output.flatten)
+  end
+
+  should "create the header file service call declarations" do
+    mock_name = "MockPoutPoutFish"
+
+    output = []
+    expected = [ "void #{mock_name}_Init(void);\n",
+                 "void #{mock_name}_Destroy(void);\n",
+                 "void #{mock_name}_Verify(void);\n\n"
+               ]
+    
+    @cmock_generator.create_mock_header_service_call_declarations(output)
+    
+    assert_equal(expected, output)
+  end
+  
+  should "append the proper footer to the header file" do 
+    output = []
+    expected = ["\n#endif\n"]
+    
+    @cmock_generator.create_mock_header_footer(output)
+    
+    assert_equal(expected, output)
+  end
+  
+  should "create a proper heading for a source file" do
+    output = []
+    expected = [ "/* AUTOGENERATED FILE. DO NOT EDIT. */\n",
+                 "#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"
+               ]
+  
+    @cmock_generator.create_source_header_section(output, "MockPoutPoutFish.c")
+    
+    assert_equal(expected, output)
+  end
+  
+  should "create the instance structure where it is needed when no functions" do 
+    output = []
+    functions = []
+    expected = [ "static struct MockPoutPoutFishInstance\n",
+                 "{\n",
+                 "  unsigned char placeHolder;\n",
+                 "} Mock;\n\n"
+               ].join
+    
+    @cmock_generator.create_instance_structure(output, functions)
+    
+    assert_equal(expected, output.join)
+  end
+  
+  should "create the instance structure where it is needed when functions required" do 
+    output = []
+    functions = [ { :name => "First", :args => "int Candy", :return => test_return[:int] }, 
+                  { :name => "Second", :args => "bool Smarty", :return => test_return[:string] }
+                ]
+    expected = [ "typedef struct _CMOCK_First_CALL_INSTANCE\n{\n",
+                 "  UNITY_LINE_TYPE LineNumber;\n",
+                 "  b1  b2",
+                 "\n} CMOCK_First_CALL_INSTANCE;\n\n",
+                 "typedef struct _CMOCK_Second_CALL_INSTANCE\n{\n",
+                 "  UNITY_LINE_TYPE LineNumber;\n",
+                 "\n} CMOCK_Second_CALL_INSTANCE;\n\n",
+                 "static struct MockPoutPoutFishInstance\n{\n",
+                 "  d1",
+                 "  CMOCK_MEM_INDEX_TYPE First_CallInstance;\n",
+                 "  e1  e2  e3",
+                 "  CMOCK_MEM_INDEX_TYPE Second_CallInstance;\n",
+                 "} Mock;\n\n"
+               ].join
+    @plugins.expect.run(:instance_typedefs, functions[0]).returns(["  b1","  b2"])
+    @plugins.expect.run(:instance_typedefs, functions[1]).returns([])
+
+    @plugins.expect.run(:instance_structure, functions[0]).returns(["  d1"])
+    @plugins.expect.run(:instance_structure, functions[1]).returns(["  e1","  e2","  e3"])
+    
+    @cmock_generator.create_instance_structure(output, functions)
+    
+    assert_equal(expected, output.join)
+  end
+  
+  should "create extern declarations for source file" do
+    output = []
+    expected = [ "extern jmp_buf AbortFrame;\n",
+                 "\n" ]
+    
+    @cmock_generator.create_extern_declarations(output)
+    
+    assert_equal(expected, output.flatten)
+  end
+  
+  should "create extern declarations for source file when using strict ordering" do
+    output = []
+    expected = [ "extern jmp_buf AbortFrame;\n",
+                 "extern int GlobalExpectCount;\n",
+                 "extern int GlobalVerifyOrder;\n",
+                 "\n" ]
+    
+    @cmock_generator_strict.create_extern_declarations(output)
+    
+    assert_equal(expected, output.flatten)
+  end
+  
+  should "create mock verify functions in source file when no functions specified" do
+    functions = []
+    output = []
+    expected = "void MockPoutPoutFish_Verify(void)\n{\n}\n\n"
+    
+    @cmock_generator.create_mock_verify_function(output, functions)
+    
+    assert_equal(expected, output.join)
+  end
+  
+  should "create mock verify functions in source file when extra functions specified" do
+    functions = [ { :name => "First", :args => "int Candy", :return => test_return[:int] }, 
+                  { :name => "Second", :args => "bool Smarty", :return => test_return[:string] } 
+                ]
+    output = []
+    expected = [ "void MockPoutPoutFish_Verify(void)\n{\n",
+                 "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
+                 "  Uno_First" +
+                 "  Dos_First" +
+                 "  Uno_Second" +
+                 "  Dos_Second",
+                 "}\n\n"
+               ]
+    @plugins.expect.run(:mock_verify, functions[0]).returns(["  Uno_First","  Dos_First"])
+    @plugins.expect.run(:mock_verify, functions[1]).returns(["  Uno_Second","  Dos_Second"])
+    
+    @cmock_generator.ordered = true
+    @cmock_generator.create_mock_verify_function(output, functions)
+    
+    assert_equal(expected, output.flatten)
+  end
+  
+  should "create mock init functions in source file" do
+    output = []
+    expected = [ "void MockPoutPoutFish_Init(void)\n{\n",
+                 "  MockPoutPoutFish_Destroy();\n",
+                 "}\n\n"
+               ]
+
+    @cmock_generator.create_mock_init_function(output)
+    
+    assert_equal(expected.join, output.join)
+  end
+  
+  should "create mock destroy functions in source file" do
+    functions = []
+    output = []
+    expected = [ "void MockPoutPoutFish_Destroy(void)\n{\n",
+                 "  CMock_Guts_MemFreeAll();\n",
+                 "  memset(&Mock, 0, sizeof(Mock));\n",
+                 "}\n\n"
+               ]
+
+    @cmock_generator.create_mock_destroy_function(output, functions)
+
+    assert_equal(expected.join, output.join)
+  end
+  
+  should "create mock destroy functions in source file when specified with strict ordering" do
+    functions = [ { :name => "First", :args => "int Candy", :return => test_return[:int] }, 
+                  { :name => "Second", :args => "bool Smarty", :return => test_return[:string] } 
+                ]
+    output = []
+    expected = [ "void MockPoutPoutFish_Destroy(void)\n{\n",
+                 "  CMock_Guts_MemFreeAll();\n",
+                 "  memset(&Mock, 0, sizeof(Mock));\n",
+                 "  uno",
+                 "  GlobalExpectCount = 0;\n",
+                 "  GlobalVerifyOrder = 0;\n",
+                 "}\n\n"
+               ]
+    @plugins.expect.run(:mock_destroy, functions[0]).returns([])
+    @plugins.expect.run(:mock_destroy, functions[1]).returns(["  uno"])
+    
+    @cmock_generator_strict.create_mock_destroy_function(output, functions)
+
+    assert_equal(expected.join, output.join)
+  end
+  
+  should "create mock implementation functions in source file" do
+    function = { :modifier => "static", 
+                 :return => test_return[:int], 
+                 :args_string => "uint32 sandwiches, const char* named", 
+                 :args => ["uint32 sandwiches", "const char* named"],
+                 :var_arg => nil,
+                 :name => "SupaFunction",
+                 :attributes => "__inline"
+               }
+    output = []
+    expected = [ "static int SupaFunction(uint32 sandwiches, const char* named)\n",
+                 "{\n",
+                 "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
+                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.SupaFunction_CallInstance);\n",
+                 "  Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
+                 "  uno",
+                 "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n",
+                 "  cmock_line = cmock_call_instance->LineNumber;\n",
+                 "  dos",
+                 "  tres",
+                 "  return cmock_call_instance->ReturnVal;\n",
+                 "}\n\n"
+               ]
+    @plugins.expect.run(:mock_implementation_precheck, function).returns(["  uno"])
+    @plugins.expect.run(:mock_implementation, function).returns(["  dos","  tres"])
+    
+    @cmock_generator.create_mock_implementation(output, function)
+    
+    assert_equal(expected.join, output.join)
+  end
+  
+  should "create mock implementation functions in source file with different options" do
+    function = { :modifier => "", 
+                 :c_calling_convention => "__stdcall",
+                 :return => test_return[:int], 
+                 :args_string => "uint32 sandwiches", 
+                 :args => ["uint32 sandwiches"],
+                 :var_arg => "corn ...",
+                 :name => "SupaFunction",
+                 :attributes => nil
+               }
+    output = []
+    expected = [ "int __stdcall SupaFunction(uint32 sandwiches, corn ...)\n",
+                 "{\n",
+                 "  UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;\n",
+                 "  CMOCK_SupaFunction_CALL_INSTANCE* cmock_call_instance = (CMOCK_SupaFunction_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.SupaFunction_CallInstance);\n",
+                 "  Mock.SupaFunction_CallInstance = CMock_Guts_MemNext(Mock.SupaFunction_CallInstance);\n",
+                 "  uno",
+                 "  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, \"Function 'SupaFunction' called more times than expected.\");\n",
+                 "  cmock_line = cmock_call_instance->LineNumber;\n",
+                 "  dos",
+                 "  tres",
+                 "  return cmock_call_instance->ReturnVal;\n",
+                 "}\n\n"
+               ]
+    @plugins.expect.run(:mock_implementation_precheck, function).returns(["  uno"])
+    @plugins.expect.run(:mock_implementation, function).returns(["  dos","  tres"])
+    
+    @cmock_generator.create_mock_implementation(output, function)
+    
+    assert_equal(expected.join, output.join)
+  end
+end