ceedling 0.12.2 → 0.13.0.rc1

data/test_graveyard/unit/busted/file_path_utils_test.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'file_path_utils'
+
+
+class FilePathUtilsTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :file_wrapper)
+    @utils = FilePathUtils.new(objects)
+  end
+
+  def teardown
+  end
+
+
+  should "standardize paths with forward slash file separators and prepend with ./" do
+    assert_equal('files/dir/dir',       FilePathUtils::standardize("files\\dir\\dir/"))
+    assert_equal('root/subdir/dir',     FilePathUtils::standardize("root\\subdir\\dir\\"))
+    assert_equal('files/modules/tests', FilePathUtils::standardize("files/modules/tests"))
+    assert_equal('source/modules',      FilePathUtils::standardize("source\\modules"))
+    assert_equal('source/modules',      FilePathUtils::standardize("./source\\modules"))
+    assert_equal('source/modules',      FilePathUtils::standardize(".\\source\\modules"))
+    assert_equal('',                    FilePathUtils::standardize("./"))
+    assert_equal('.',                   FilePathUtils::standardize("."))
+  end
+
+
+  should "find base directory up to glob notation or filename" do    
+    assert_equal('/files/stuff',  FilePathUtils::dirname('/files/stuff/'))
+    assert_equal('/files/stuff',  FilePathUtils::dirname('/files/stuff'))
+    assert_equal('.',             FilePathUtils::dirname('.'))
+
+    assert_equal('.',             FilePathUtils::dirname('./*'))
+    assert_equal('/files/stuff',  FilePathUtils::dirname('/files/stuff/**'))
+    assert_equal('/files/stuff',  FilePathUtils::dirname('/files/stuff/*'))
+    assert_equal('/files/stuff',  FilePathUtils::dirname('/files/stuff/**/more*'))
+    assert_equal('files/tests',   FilePathUtils::dirname('files/tests/*test/**/thing*/**'))
+    assert_equal('files',         FilePathUtils::dirname('files/test*'))
+
+    assert_equal('files/tests',   FilePathUtils::dirname('files/tests/???src'))
+    assert_equal('project/files', FilePathUtils::dirname('project/files/test?'))
+
+    assert_equal('project/files', FilePathUtils::dirname('project/files/test[123]'))
+
+    assert_equal('project/files', FilePathUtils::dirname('project/files/test{ing,s}'))
+
+    assert_equal('project/files', FilePathUtils::dirname('project/files/**/**'))
+  end
+
+
+  should "form valid subdirectory recursing globs from path convention" do
+    assert_equal('/files/stuff/', FilePathUtils::reform_glob('/files/stuff/'))
+    assert_equal('/files/stuff',  FilePathUtils::reform_glob('/files/stuff'))
+    assert_equal('.',             FilePathUtils::reform_glob('.'))
+
+    assert_equal('./*',                               FilePathUtils::reform_glob('./*'))
+    assert_equal('/files/stuff/**/**',                FilePathUtils::reform_glob('/files/stuff/**'))
+    assert_equal('/files/stuff/*',                    FilePathUtils::reform_glob('/files/stuff/*'))
+    assert_equal('/files/stuff/**/more*',             FilePathUtils::reform_glob('/files/stuff/**/more*'))
+    assert_equal('files/tests/*test/**/thing*/**/**', FilePathUtils::reform_glob('files/tests/*test/**/thing*/**'))
+
+    assert_equal('files/tests/???src',  FilePathUtils::reform_glob('files/tests/???src'))
+    assert_equal('project/files/test?', FilePathUtils::reform_glob('project/files/test?'))
+
+    assert_equal('project/files/test[123]', FilePathUtils::reform_glob('project/files/test[123]'))
+
+    assert_equal('project/files/test{ing,s}', FilePathUtils::reform_glob('project/files/test{ing,s}'))
+  end
+
+
+  should "form runner object file path from configuration and file name" do
+    @configurator.expects.project_test_build_output_path.returns('project/build/output')
+    @configurator.expects.extension_object.returns('.obj')
+    @configurator.expects.extension_object.returns('.obj')
+    @configurator.expects.test_runner_file_suffix.returns('_runner')
+    
+    assert_equal('project/build/output/test_stuff_runner.obj', @utils.form_runner_object_filepath_from_test('files/junk/test_stuff.c'))
+  end
+
+
+  should "form runner object file path from configuration and file name" do
+    @configurator.expects.project_test_build_output_path.returns('project/build/output')
+    @configurator.expects.extension_object.returns('.o')
+    
+    assert_equal('project/build/output/stuff.o', @utils.form_object_filepath('files/junk/stuff.c'))
+  end
+
+
+  should "form executable file path from configuration and file name" do
+    @configurator.expects.project_test_build_output_path.returns('project/build/output')
+    @configurator.expects.extension_executable.returns('.out')
+    
+    assert_equal('project/build/output/test_stuff.out', @utils.form_executable_filepath('files/tests/test_stuff.c'))
+  end
+
+end
+

data/test_graveyard/unit/busted/file_system_utils_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'file_system_utils'
+
+
+class FileSystemUtilsTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:file_wrapper)
+    utils = FileSystemUtils.new(objects)
+  end
+
+  def teardown
+  end
+
+
+  should "" do    
+    # dummy placeholder test; all tests are system tests (system/paths_test) for this guy
+  end
+
+end
+

data/test_graveyard/unit/busted/generator_test.rb

@@ -0,0 +1,187 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'generator'
+
+
+class GeneratorTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :preprocessinator, :cmock_factory, :generator_test_runner, :generator_test_results, :test_includes_extractor, :tool_executor, :file_finder, :file_path_utils, :streaminator, :plugin_manager, :file_wrapper)
+    create_mocks(:cmock, :file)
+    @generator = Generator.new(objects)
+  end
+
+  def teardown
+  end
+
+  ################### includes preprocessing ####################  
+
+  should "generate shallow includes list file" do
+    @preprocessinator.expects.preprocess_shallow_includes('project/tests/test_file.c')
+    
+    @generator.generate_shallow_includes_list('project/tests/test_file.c')
+  end
+
+  ################### file preprocessing ####################  
+
+  should "generate preprocessed version of file" do
+    @streaminator.expects.stdout_puts("Preprocessing test_icle.c...", Verbosity::NORMAL)
+    
+    @preprocessinator.expects.preprocess_file('project/tests/test_icle.c')
+    
+    @generator.generate_preprocessed_file('project/tests/test_icle.c')
+  end
+
+  ################### auxiliary dependencies ####################  
+
+  should "generate auxiliary dependencies file" do
+    @streaminator.expects.stdout_puts("Generating dependencies for file.c...", Verbosity::NORMAL)
+
+    @configurator.expects.tools_dependencies_generator.returns('gcc -depgen')
+    @file_path_utils.expects.form_object_filepath('project/files/src/file.c').returns('project/build/file.o')
+    
+    @tool_executor.expects.build_command_line('gcc -depgen', 'project/files/src/file.c', ['types.h', 'helper.h'], 'project/build/file.o').returns('dep cmd line')
+    
+    @tool_executor.expects.exec('dep cmd line')
+    
+    @generator.generate_dependencies_file('project/files/src/file.c', ['types.h', 'helper.h'])
+  end
+
+  ################### cmock ####################  
+  
+  should "manufacture cmock object if not already in existence and verify that cmock gets called" do
+    test_source_header1       = 'files/source/mockable1.h'
+    test_preprocessed_header1 = 'files/preprocessed/mockable1.h'
+    test_source_header2       = 'files/source/mockable2.h'
+    test_preprocessed_header2 = 'files/preprocessed/mockable2.h'
+    
+    # instantiate cmock as it doesn't exist and then call against to create mock
+    @configurator.expects.cmock_config_hash.returns({:cmock => []})
+    @cmock_factory.expects.manufacture({:cmock => []}).returns(@cmock)
+    @preprocessinator.expects.form_file_path(test_source_header1).returns(test_preprocessed_header1)
+    @cmock.expects.setup_mocks(test_preprocessed_header1)
+    @generator.generate_mock(test_source_header1)
+
+    # don't instantiate cmock as it already exists and then against it to create mock
+    @preprocessinator.expects.form_file_path(test_source_header2).returns(test_preprocessed_header2)
+    @cmock.expects.setup_mocks(test_preprocessed_header2)
+    @generator.generate_mock(test_source_header2)
+  end
+
+  ################### test runner ####################  
+
+  should "generate test runner" do
+    test_source         = 'tests/test_count_chocula.c'
+    preprocessed_source = 'preprocessed/test_count_chocula.c'
+    test_runner         = 'build/runners/test_count_chocula_runner.c'
+    test_cases          = ['test_how_much_goodness', 'test_chocolatey_milk']
+    mock_list           = ['mock_marshmallows.h', 'mock_cereal_bits.h']
+
+    @preprocessinator.expects.form_file_path(test_source).returns(preprocessed_source)
+    
+    @generator_test_runner.expects.find_test_cases(preprocessed_source).returns(test_cases)
+    @test_includes_extractor.expects.lookup_raw_mock_list(preprocessed_source).returns(mock_list)
+    
+    @streaminator.expects.stdout_puts("Creating test runner for test_count_chocula.c...", Verbosity::NORMAL)
+    
+    @file_wrapper.expects.open(test_runner, 'w').yields(@file)
+    
+    @generator_test_runner.expects.create_header(@file, mock_list)
+    @generator_test_runner.expects.create_externs(@file, test_cases)
+    @generator_test_runner.expects.create_mock_management(@file, mock_list)
+    @generator_test_runner.expects.create_runtest(@file, mock_list, test_cases)
+    @generator_test_runner.expects.create_main(@file, 'test_count_chocula.c', test_cases)
+        
+    @generator.generate_test_runner(test_source, test_runner)
+  end
+
+  ################### compilation ####################  
+
+  should "compile object file" do
+    tool_config = {:tools_test_compiler => {}}
+
+    @streaminator.expects.stdout_puts("Compiling compile_me.c...", Verbosity::NORMAL)
+    
+    @configurator.expects.tools_test_compiler.returns(tool_config)
+    
+    @tool_executor.expects.build_command_line(tool_config, 'files/modules/compile_me.c', 'build/out/compile_me.o').returns('compiler.exe input output')
+    @tool_executor.expects.exec('compiler.exe input output').returns('ignore this')
+
+    @generator.generate_object_file('files/modules/compile_me.c', 'build/out/compile_me.o')
+  end
+
+  ################### linking ####################  
+
+  should "link executable file" do
+    tool_config = {:tools_test_linker => {}}
+
+    @streaminator.expects.stdout_puts("Linking link_me.out...", Verbosity::NORMAL)
+    
+    @configurator.expects.tools_test_linker.returns(tool_config)
+    
+    @tool_executor.expects.build_command_line(tool_config, ['build/out/compile_me.o', 'build/out/compile_me_too.o'], 'build/out/link_me.out').returns('linker.exe input output')
+    @tool_executor.expects.exec('linker.exe input output').returns('ignore this')
+
+    @generator.generate_executable_file(['build/out/compile_me.o', 'build/out/compile_me_too.o'], 'build/out/link_me.out')
+  end
+
+  ################### test execution ####################  
+
+  should "execute test and process results to file" do
+    tool_config = {:tools_test_runner => {}}
+    arg_hash = {:executable => 'build/out/test.out', :result => 'build/results/test.pass'}
+
+    @plugin_manager.expects.pre_test_fixture_execute(arg_hash)
+    
+    @streaminator.expects.stdout_puts("Running test.out...", Verbosity::NORMAL)
+    
+    @configurator.expects.tools_test_fixture.returns(tool_config)
+    
+    @tool_executor.expects.build_command_line(tool_config, arg_hash[:executable]).returns('simulator.exe test.out')
+    @tool_executor.expects.exec('simulator.exe test.out').returns('test results')
+
+    @file_finder.expects.find_test_from_file_path(arg_hash[:executable]).returns('tests/test.c')
+    
+    @generator_test_results.expects.process_and_write_results('test results', arg_hash[:result], 'tests/test.c')
+
+    @plugin_manager.expects.post_test_fixture_execute(arg_hash)
+
+    @generator.generate_test_results(arg_hash[:executable], arg_hash[:result])    
+  end
+
+  should "raise if test execution yields nil results" do
+    tool_config = {:tools_test_runner => {}}
+    arg_hash = {:executable => 'build/out/test.out', :result => 'build/results/test.pass'}
+
+    @plugin_manager.expects.pre_test_fixture_execute(arg_hash)
+
+    @streaminator.expects.stdout_puts("Running test.out...", Verbosity::NORMAL)
+    
+    @configurator.expects.tools_test_fixture.returns(tool_config)
+    
+    @tool_executor.expects.build_command_line(tool_config, arg_hash[:executable]).returns('simulator.exe test.out')
+    @tool_executor.expects.exec('simulator.exe test.out').returns(nil)
+
+    @streaminator.expects.stderr_puts("ERROR: Test executable \"test.out\" did not produce any results.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError) { @generator.generate_test_results(arg_hash[:executable], arg_hash[:result]) }
+  end
+
+  should "raise if test execution yields a string with no parseable results" do
+    tool_config = {:tools_test_runner => {}}
+    arg_hash = {:executable => 'build/out/test.out', :result => 'build/results/test.pass'}
+
+    @plugin_manager.expects.pre_test_fixture_execute(arg_hash)
+
+    @streaminator.expects.stdout_puts("Running test.out...", Verbosity::NORMAL)
+    
+    @configurator.expects.tools_test_fixture.returns(tool_config)
+    
+    @tool_executor.expects.build_command_line(tool_config, arg_hash[:executable]).returns('simulator.exe test.out')
+    @tool_executor.expects.exec('simulator.exe test.out').returns('')
+
+    @streaminator.expects.stderr_puts("ERROR: Test executable \"test.out\" did not produce any results.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError) { @generator.generate_test_results('build/out/test.out', 'build/results/test.pass') }
+  end
+
+end

data/test_graveyard/unit/busted/generator_test_results_test.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'generator_test_results'
+
+
+class GeneratorTestResultsTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :yaml_wrapper, :streaminator)
+    @utils = GeneratorTestResults.new(objects)
+  end
+
+  def teardown
+  end
+
+  
+  should "complain if output from test fixture includes messed up statistics" do
+
+    # no ignore count
+    raw_unity_output1 = %Q[
+      13 Tests 0 Failures
+      ].left_margin(0)
+
+    @configurator.expects.extension_executable.returns('.exe')
+    @streaminator.expects.stderr_puts("ERROR: Results from test fixture 'TestIng.exe' are missing or are malformed.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError){ @utils.process_and_write_results(raw_unity_output1, 'project/build/results/TestIng.pass', 'files/tests/TestIng.c') }
+
+    # 'Test' not pluralized
+    raw_unity_output2 = %Q[
+      13 Test 0 Failures 3 Ignored
+      ].left_margin(0)
+
+    @configurator.expects.extension_executable.returns('.out')
+    @streaminator.expects.stderr_puts("ERROR: Results from test fixture 'TestIcular.out' are missing or are malformed.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError){ @utils.process_and_write_results(raw_unity_output2, 'project/build/results/TestIcular.pass', 'files/tests/TestIcular.c') }
+  end
+
+
+  should "write a mixture of test results to a .fail file" do
+    
+    # test fixture output with blank lines and junk past the statistics line
+    raw_unity_output = %Q[
+           
+      test_a_file.c:13:test_a_single_thing:IGNORE:pay no attention to the test behind the curtain
+      test_a_file.c:18:test_another_thing:IGNORE:pay no attention to the:stray colon
+      test_a_file.c:35:test_your_knowledge:FAIL:Expected TRUE was FALSE
+      test_a_file.c:42:test_a_success_case:PASS
+      
+      test_a_file.c:47:test_another_thing:FAIL
+      test_a_file.c:53:test_some_non_void_param_stuff:IGNORE:pay no attention to the test behind the curtain
+      test_a_file.c:60:test_some_multiline_test_case_action:IGNORE:pay no attention to the test behind the curtain
+      
+      test_a_file.c:65:test_another_success_case:PASS
+      test_a_file.c:78:test_yet_another_success_case:PASS
+      test_a_file.c:92:test_a_final_thing:FAIL:BOOM!
+      10 Tests 3 Failures 4 Ignored
+      FAIL
+      // a random comment to be ignored
+      ].left_margin(0)
+    
+    expected_hash = {
+      :counts => {:total => 10, :failed => 3, :ignored => 4, :passed => 3},
+      :source => {:path => 'files/tests', :file => 'test_a_file.c'},
+      :failures => [
+        {:test => 'test_your_knowledge', :line => 35, :message => 'Expected TRUE was FALSE'},
+        {:test => 'test_another_thing', :line => 47, :message => ''},
+        {:test => 'test_a_final_thing', :line => 92, :message => 'BOOM!'},
+        ],
+      :ignores => [
+        {:test => 'test_a_single_thing', :line => 13, :message => 'pay no attention to the test behind the curtain'},
+        {:test => 'test_another_thing', :line => 18, :message => 'pay no attention to the:stray colon'},
+        {:test => 'test_some_non_void_param_stuff', :line => 53, :message => 'pay no attention to the test behind the curtain'},
+        {:test => 'test_some_multiline_test_case_action', :line => 60, :message => 'pay no attention to the test behind the curtain'},
+        ],
+      :successes => [
+        {:test => 'test_a_success_case', :line => 42, :message => ''},
+        {:test => 'test_another_success_case', :line => 65, :message => ''},
+        {:test => 'test_yet_another_success_case', :line => 78, :message => ''},
+        ]
+      }
+    
+    @configurator.expects.extension_testfail.returns('.fail')
+    
+    @yaml_wrapper.expects.dump('project/build/results/test_a_file.fail', expected_hash)
+    
+    @utils.process_and_write_results(raw_unity_output, 'project/build/results/test_a_file.pass', 'files/tests/test_a_file.c')
+    
+  end
+
+
+  should "write a mixture of test results to a .pass file" do
+    
+    # clean test fixture output
+    raw_unity_output = %Q[
+      test_eez.c:13:test_a_single_thing:IGNORE:pay no attention to the test behind the curtain
+      test_eez.c:18:test_another_thing:IGNORE:pay no attention to the test behind the curtain
+      test_eez.c:30:test_a_success_case:PASS
+      test_eez.c:60:test_some_multiline_test_case_action:IGNORE:pay no attention to the stray:colon
+      test_eez.c:73:test_another_success_case:PASS
+      test_eez.c:83:test_yet_another_success_case:PASS
+      6 Tests 0 Failures 3 Ignored
+      OK
+      ].left_margin(0)
+    
+    expected_hash = {
+      :counts => {:total => 6, :failed => 0, :ignored => 3, :passed => 3},
+      :source => {:path => 'files/tests', :file => 'test_eez.c'},
+      :failures => [],
+      :ignores => [
+        {:test => 'test_a_single_thing', :line => 13, :message => 'pay no attention to the test behind the curtain'},
+        {:test => 'test_another_thing', :line => 18, :message => 'pay no attention to the test behind the curtain'},
+        {:test => 'test_some_multiline_test_case_action', :line => 60, :message => 'pay no attention to the stray:colon'},
+        ],
+      :successes => [
+        {:test => 'test_a_success_case', :line => 30, :message => ''},
+        {:test => 'test_another_success_case', :line => 73, :message => ''},
+        {:test => 'test_yet_another_success_case', :line => 83, :message => ''},
+        ]
+      }
+    
+    @yaml_wrapper.expects.dump('project/build/results/test_eez.pass', expected_hash)
+    
+    @utils.process_and_write_results(raw_unity_output, 'project/build/results/test_eez.pass', 'files/tests/test_eez.c')
+    
+  end
+
+end
+

data/test_graveyard/unit/busted/generator_test_runner_test.rb

@@ -0,0 +1,478 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'generator_test_runner'
+
+
+# redefine split for convenience of file content comparison in tests.
+# this is needed because we're using the '<<' operator on real files in source but substituting
+#  an array for file writes in the tests; the '<<' operator tacks on new lines when used with a file,
+#  but, of course, does not do this when inserting into an array.
+class String
+  def newline_split(pattern=/\n/, limit=nil)
+    return (split(pattern, limit)).map{|elem| elem + "\n"} if !limit.nil?
+    return (split(pattern)       ).map{|elem| elem + "\n"}
+  end
+end
+
+
+#NOTE: When using newline_split() & left_margin() to manage test code strings,
+#      white space to the left of newlines in otherwise blank lines is important.
+#      That is, *every* line in a test code block must be spaced over.
+
+
+class GeneratorTestRunnerTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :file_wrapper)
+    @runner_utils = GeneratorTestRunner.new(objects)
+  end
+
+  def teardown
+  end
+
+  
+  ######### find test cases #########
+    
+  should "find test case functions in preprocessed test file" do
+    test_file = 'tests/test_me.c'
+    
+    test_me_c = %Q[
+      #include "unity.h"
+      #include "Oscar.h"
+      #include "mock_abilly.h"
+      #include "mock_and_roll.h "
+
+      void test_some_stuff(void)
+      {
+        TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+      }
+
+       void  test_some_more_stuff ( void )
+      {
+        TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+      }
+
+      void test_some_non_void_param_stuff()
+      {
+        TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+      }
+
+      void
+      test_some_multiline_test_case_action
+      (void)
+      {
+        TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+      }
+
+    ].left_margin(0)
+    
+    @configurator.expects.project_use_preprocessor.returns(true)
+    
+    @file_wrapper.expects.read(test_file).returns(test_me_c)
+    
+    assert_equal(
+      ['test_some_stuff',
+       'test_some_more_stuff',
+       'test_some_non_void_param_stuff',
+       'test_some_multiline_test_case_action'
+      ],
+      @runner_utils.find_test_cases(test_file))
+  end
+
+  should "find test case functions in non-preprocessed test file (do some basic pre-processing with regex)" do
+    test_file = 'tests/test_me.c'
+
+    test_me_c = %Q[
+        #include "unity.h"
+        #include "Oscar.h"
+        #include "mock_abilly.h"
+        #include "mock_and_roll.h "
+
+        #ifdef SOMETHING
+        extern void test_a_thing_to_throw_off_scanning(void);
+        #end
+
+        //void test_some_stuff(void)
+        //{
+        //  TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+        //}
+
+        /*
+         void  test_some_more_stuff ( void )
+        {
+          TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+        }*/
+
+        void test_some_non_void_param_stuff()
+        {
+          TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+        }
+
+        void
+        test_some_multiline_test_case_action
+        (void)
+        {
+          TEST_ASSERT_IGNORE("pay no attention to the test behind the curtain");
+        }
+
+      ].left_margin(0)
+
+    @configurator.expects.project_use_preprocessor.returns(false)
+
+    @file_wrapper.expects.read(test_file).returns(test_me_c)
+
+    assert_equal(
+      ['test_some_non_void_param_stuff',
+       'test_some_multiline_test_case_action'
+      ],
+      @runner_utils.find_test_cases(test_file))
+  end
+
+
+  ######### header block #########
+
+  should "create header block of include statements and internal variables for exception handling, mocks, and strict ordering" do
+    file = []
+    
+    expected_output = %Q[
+      /* AUTOGENERATED FILE. DO NOT EDIT. */
+      #include "unity.h"
+      #include "extra_thing1.h"
+      #include "extra_thing2.h"
+      #include <setjmp.h>
+      #include <stdio.h>
+      #include "CException.h"
+      #include "mock_abc.h"
+      #include "mock_123.h"
+
+      int GlobalExpectCount;
+      int GlobalVerifyOrder;
+      char* GlobalOrderError;
+
+      char MessageBuffer[50];
+      ].left_margin(0)
+    
+    @configurator.expects.test_runner_includes.returns(['extra_thing1.h', 'extra_thing2.h'])
+    @configurator.expects.project_use_exceptions.returns(true)
+    @configurator.expects.extension_header.returns('.h')
+    @configurator.expects.cmock_enforce_strict_ordering.returns(true)
+        
+    @runner_utils.create_header(file, ['mock_abc', 'mock_123'])
+    
+    assert_equal(expected_output.newline_split[1..-1], file)
+  end
+
+  should "create header block of include statements and internal variables for exception handling & mocks but without strict ordering" do
+    file = []
+
+    expected_output = %Q[
+      /* AUTOGENERATED FILE. DO NOT EDIT. */
+      #include "unity.h"
+      #include "extra_thing1.h"
+      #include "extra_thing2.h"
+      #include <setjmp.h>
+      #include <stdio.h>
+      #include "CException.h"
+      #include "mock_abc.H"
+      #include "mock_123.H"
+
+      char MessageBuffer[50];
+      ].left_margin(0)
+
+    @configurator.expects.test_runner_includes.returns(['extra_thing1.h', 'extra_thing2.h'])
+    @configurator.expects.project_use_exceptions.returns(true)
+    @configurator.expects.extension_header.returns('.H')
+    @configurator.expects.cmock_enforce_strict_ordering.returns(false)
+
+    @runner_utils.create_header(file, ['mock_abc', 'mock_123'])
+
+    assert_equal(expected_output.newline_split[1..-1], file)
+  end
+
+  should "create header block of include statements and internal variables for no extra header files, exception handling, or mocks" do
+    file = []
+
+    expected_output = %Q[
+      /* AUTOGENERATED FILE. DO NOT EDIT. */
+      #include "unity.h"
+      #include <setjmp.h>
+      #include <stdio.h>
+
+      char MessageBuffer[50];
+      ].left_margin(0)
+
+    @configurator.expects.test_runner_includes.returns([])
+    @configurator.expects.project_use_exceptions.returns(false)
+
+    @runner_utils.create_header(file, [])
+
+    assert_equal(expected_output.newline_split[1..-1], file)
+  end
+
+
+  ######### extern block #########
+    
+  should "create extern block of setup, teardown, and test cases" do
+    file = []
+
+    expected_output = %Q[
+      extern void setUp(void);
+      extern void tearDown(void);
+
+      extern void test_case1(void);
+      extern void test_case2(void);
+      extern void test_case3(void);
+      ].left_margin(0)
+
+    @runner_utils.create_externs(file, ['test_case1', 'test_case2', 'test_case3'])
+
+    assert_equal(expected_output.newline_split, file)
+  end
+
+
+  should "create extern block of setup, teardown, and no test cases" do
+    file = []
+
+    expected_output = %Q[
+      extern void setUp(void);
+      extern void tearDown(void);
+      ].left_margin(0)
+
+    @runner_utils.create_externs(file, [])
+
+    assert_equal(expected_output.newline_split, file)
+  end
+
+
+  ######### mock management #########
+
+  should "create mock management block for given mock list with strict ordering" do
+    file = []
+
+    expected_output = %Q[
+      static void CMock_Init(void)
+      {
+        GlobalExpectCount = 0;
+        GlobalVerifyOrder = 0;
+        GlobalOrderError = NULL;
+        mock_thinger_Init();
+        mock_stinger_Init();
+        mock_zinger_Init();
+      }
+
+      static void CMock_Verify(void)
+      {
+        mock_thinger_Verify();
+        mock_stinger_Verify();
+        mock_zinger_Verify();
+      }
+
+      static void CMock_Destroy(void)
+      {
+        mock_thinger_Destroy();
+        mock_stinger_Destroy();
+        mock_zinger_Destroy();
+      }
+
+      void CMock_VerifyAndReset(void)
+      {
+        CMock_Verify();
+        CMock_Destroy();
+        CMock_Init();
+      }
+      ].left_margin(0)
+
+    @configurator.expects.extension_header.returns('.h')
+    @configurator.expects.cmock_enforce_strict_ordering.returns(true)
+
+    @runner_utils.create_mock_management(file, ['mock_thinger.h', 'mock_stinger.h', 'mock_zinger.h'])
+
+    assert_equal(expected_output.newline_split + ["\n"], file) # add newline array element that split won't do
+  end
+
+  should "create mock management block for given mock list without strict ordering" do
+    file = []
+
+    expected_output = %Q[
+      static void CMock_Init(void)
+      {
+        mock_thinger_Init();
+        mock_stinger_Init();
+        mock_zinger_Init();
+      }
+
+      static void CMock_Verify(void)
+      {
+        mock_thinger_Verify();
+        mock_stinger_Verify();
+        mock_zinger_Verify();
+      }
+
+      static void CMock_Destroy(void)
+      {
+        mock_thinger_Destroy();
+        mock_stinger_Destroy();
+        mock_zinger_Destroy();
+      }
+      
+      void CMock_VerifyAndReset(void)
+      {
+        CMock_Verify();
+        CMock_Destroy();
+        CMock_Init();
+      }
+      ].left_margin(0)
+
+    @configurator.expects.extension_header.returns('.h')
+    @configurator.expects.cmock_enforce_strict_ordering.returns(false)
+
+    @runner_utils.create_mock_management(file, ['mock_thinger.h', 'mock_stinger.h', 'mock_zinger.h'])
+
+    assert_equal(expected_output.newline_split + ["\n"], file) # add newline array element that split won't do
+  end
+
+  should "create empty mock management block for empty mock list" do
+    file = []
+    
+    @runner_utils.create_mock_management(file, [])
+
+    assert_equal([], file)
+  end
+
+
+  ######### runTest() #########
+
+  should "create no runTest function if there's no test cases (to prevent unused function compilation warnings)" do
+    file = []
+    @runner_utils.create_runtest(file, [], [])
+    assert_equal([], file)
+  end
+
+  should "create runTest function including mock and exception handling" do
+    file = []
+    
+    expected_output = %Q[
+      static void runTest(UnityTestFunction test)
+      {
+        if (TEST_PROTECT())
+        {
+          CEXCEPTION_T e;
+          Try {
+            CMock_Init();
+            setUp();
+            test();
+            CMock_Verify();
+          } Catch(e) { TEST_FAIL("Unhandled Exception!"); }
+        }
+        CMock_Destroy();
+        if (TEST_PROTECT())
+        {
+          tearDown();
+        }
+      }
+      ].left_margin(0)
+    
+    @configurator.expects.project_use_exceptions.returns(true)
+    
+    @runner_utils.create_runtest(file, ['mock_zinger.h'], ['test_icle.c', 'test_ing.c'])
+    assert_equal(expected_output.newline_split, file)
+  end
+
+  should "create runTest function including mock handling but no exception handling" do
+    file = []
+
+    expected_output = %Q[
+      static void runTest(UnityTestFunction test)
+      {
+        if (TEST_PROTECT())
+        {
+          CMock_Init();
+          setUp();
+          test();
+          CMock_Verify();
+        }
+        CMock_Destroy();
+        if (TEST_PROTECT())
+        {
+          tearDown();
+        }
+      }
+      ].left_margin(0)
+
+    @configurator.expects.project_use_exceptions.returns(false)
+
+    @runner_utils.create_runtest(file, ['mock_zinger.h'], ['test_icle.c', 'test_ing.c'])
+    assert_equal(expected_output.newline_split, file)
+  end
+
+  should "create runTest function including no mock handling but including exception handling" do
+    file = []
+
+    expected_output = %Q[
+      static void runTest(UnityTestFunction test)
+      {
+        if (TEST_PROTECT())
+        {
+          CEXCEPTION_T e;
+          Try {
+            setUp();
+            test();
+          } Catch(e) { TEST_FAIL("Unhandled Exception!"); }
+        }
+        if (TEST_PROTECT())
+        {
+          tearDown();
+        }
+      }
+      ].left_margin(0)
+
+    @configurator.expects.project_use_exceptions.returns(true)
+
+    @runner_utils.create_runtest(file, [], ['test_icle.c', 'test_ing.c'])
+    assert_equal(expected_output.newline_split, file)
+  end
+
+  ######### main() #########
+
+  should "create main function with test cases" do
+    file = []
+
+    expected_output = %Q[
+      int main(void)
+      {
+        UnityBegin();
+        Unity.TestFile = "TestMe.c";
+
+        // RUN_TEST calls runTest
+        RUN_TEST(test_a_little_test);
+        RUN_TEST(test_a_wee_test);
+        RUN_TEST(test_a_teeny_test);
+
+        UnityEnd();
+        return 0;
+      }
+      ].left_margin(0)
+
+    @runner_utils.create_main(file, 'TestMe.c', ['test_a_little_test', 'test_a_wee_test', 'test_a_teeny_test'])
+    assert_equal(expected_output.newline_split + ["\n"], file) # add newline array element that split won't do
+  end
+
+  should "create main function with no test cases" do
+    file = []
+
+    expected_output = %Q[
+      int main(void)
+      {
+        UnityBegin();
+        Unity.TestFile = "TestIfy.c";
+
+
+        UnityEnd();
+        return 0;
+      }
+      ].left_margin(0)
+
+    @runner_utils.create_main(file, 'TestIfy.c', [])
+    assert_equal(expected_output.newline_split + ["\n"], file) # add newline array element that split won't do
+  end
+
+end