ceedling 0.19.0 → 0.20.2

data/test_graveyard/unit/busted/test_invoker_helper_test.rb

@@ -1,62 +1,62 @@
-require File.dirname(__FILE__) + '/../unit_test_helper'
-require 'ceedling/test_invoker_helper'
-
-
-class TestInvokerHelperTest < Test::Unit::TestCase
-
-  def setup
-    objects = create_mocks(:configurator, :task_invoker, :dependinator, :file_path_utils, :file_finder, :file_wrapper)
-    create_mocks(:tests_list, :sources_list, :mocks_list, :runners_list, :pass_results_list, :fail_results_list)
-    create_mocks(:dependencies_list1, :dependencies_list2, :dependencies_list3, :dependencies_list4)
-    @test_invoker_helper = TestInvokerHelper.new(objects)
-  end
-
-  def teardown
-  end
-
-
-  should "clean all result files" do
-    @file_wrapper.expects.rm_f(@fail_results_list)
-    @file_wrapper.expects.rm_f(@pass_results_list)
-    
-    @test_invoker_helper.clean_results({:force_run => true}, @fail_results_list, @pass_results_list)
-  end
-
-  should "clean only fail result files" do
-    @file_wrapper.expects.rm_f(@fail_results_list)
-    
-    @test_invoker_helper.clean_results({:force_run => false}, @fail_results_list, @pass_results_list)    
-  end
-
-  should "process no auxiliary dependencies" do
-    @configurator.expects.project_use_deep_dependencies.returns(false)
-    
-    @test_invoker_helper.process_deep_dependencies(@tests_list)
-  end
-
-  should "process auxiliary dependencies" do
-    @configurator.expects.project_use_deep_dependencies.returns(true)
-    
-    @file_finder.expects.find_sources_from_tests(@tests_list).returns(@sources_list)
-    
-    @file_path_utils.expects.form_dependencies_filelist(@tests_list).returns(@dependencies_list1)
-    @task_invoker.expects.invoke_dependencies_files(@dependencies_list1)
-    @dependinator.expects.setup_test_object_dependencies(@dependencies_list1)
-
-    @file_path_utils.expects.form_dependencies_filelist(@sources_list).returns(@dependencies_list2)
-    @task_invoker.expects.invoke_dependencies_files(@dependencies_list2)
-    @dependinator.expects.setup_test_object_dependencies(@dependencies_list2)
-
-    @file_path_utils.expects.form_dependencies_filelist(@mocks_list).returns(@dependencies_list3)
-    @task_invoker.expects.invoke_dependencies_files(@dependencies_list3)
-    @dependinator.expects.setup_test_object_dependencies(@dependencies_list3)
-
-    @file_path_utils.expects.form_dependencies_filelist(@runners_list).returns(@dependencies_list4)
-    @task_invoker.expects.invoke_dependencies_files(@dependencies_list4)
-    @dependinator.expects.setup_test_object_dependencies(@dependencies_list4)
-
-    @test_invoker_helper.process_deep_dependencies(@tests_list, @mocks_list, @runners_list)
-  end
-
-
-end
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'ceedling/test_invoker_helper'
+
+
+class TestInvokerHelperTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :task_invoker, :dependinator, :file_path_utils, :file_finder, :file_wrapper)
+    create_mocks(:tests_list, :sources_list, :mocks_list, :runners_list, :pass_results_list, :fail_results_list)
+    create_mocks(:dependencies_list1, :dependencies_list2, :dependencies_list3, :dependencies_list4)
+    @test_invoker_helper = TestInvokerHelper.new(objects)
+  end
+
+  def teardown
+  end
+
+
+  should "clean all result files" do
+    @file_wrapper.expects.rm_f(@fail_results_list)
+    @file_wrapper.expects.rm_f(@pass_results_list)
+    
+    @test_invoker_helper.clean_results({:force_run => true}, @fail_results_list, @pass_results_list)
+  end
+
+  should "clean only fail result files" do
+    @file_wrapper.expects.rm_f(@fail_results_list)
+    
+    @test_invoker_helper.clean_results({:force_run => false}, @fail_results_list, @pass_results_list)    
+  end
+
+  should "process no auxiliary dependencies" do
+    @configurator.expects.project_use_deep_dependencies.returns(false)
+    
+    @test_invoker_helper.process_deep_dependencies(@tests_list)
+  end
+
+  should "process auxiliary dependencies" do
+    @configurator.expects.project_use_deep_dependencies.returns(true)
+    
+    @file_finder.expects.find_sources_from_tests(@tests_list).returns(@sources_list)
+    
+    @file_path_utils.expects.form_dependencies_filelist(@tests_list).returns(@dependencies_list1)
+    @task_invoker.expects.invoke_dependencies_files(@dependencies_list1)
+    @dependinator.expects.setup_test_object_dependencies(@dependencies_list1)
+
+    @file_path_utils.expects.form_dependencies_filelist(@sources_list).returns(@dependencies_list2)
+    @task_invoker.expects.invoke_dependencies_files(@dependencies_list2)
+    @dependinator.expects.setup_test_object_dependencies(@dependencies_list2)
+
+    @file_path_utils.expects.form_dependencies_filelist(@mocks_list).returns(@dependencies_list3)
+    @task_invoker.expects.invoke_dependencies_files(@dependencies_list3)
+    @dependinator.expects.setup_test_object_dependencies(@dependencies_list3)
+
+    @file_path_utils.expects.form_dependencies_filelist(@runners_list).returns(@dependencies_list4)
+    @task_invoker.expects.invoke_dependencies_files(@dependencies_list4)
+    @dependinator.expects.setup_test_object_dependencies(@dependencies_list4)
+
+    @test_invoker_helper.process_deep_dependencies(@tests_list, @mocks_list, @runners_list)
+  end
+
+
+end

data/test_graveyard/unit/busted/test_invoker_test.rb

@@ -1,47 +1,47 @@
-require File.dirname(__FILE__) + '/../unit_test_helper'
-require 'ceedling/test_invoker'
-
-
-class TestInvokerTest < Test::Unit::TestCase
-
-  def setup
-    objects = create_mocks(:test_invoker_helper, :configurator, :preprocessinator, :task_invoker, :dependinator, :file_wrapper)
-    create_mocks(:tests_list, :mocks_list, :runners_list, :pass_results_list, :fail_results_list)
-    @test_invoker = TestInvoker.new(objects)
-  end
-
-  def teardown
-  end
-    
-  
-  should "run tests" do
-    @file_wrapper.expects.instantiate_file_list(['project/tests/TestIng.c', 'project/tests/TestIcular.c']).returns(@tests_list)
-
-    @configurator.expects.project_test_results_path.returns('project/build/results')
-    @configurator.expects.extension_testfail.returns('.fail')
-    @tests_list.expects.pathmap('project/build/results/%n.fail').returns(@fail_results_list)
-    @configurator.expects.project_test_results_path.returns('project/build/results')
-    @configurator.expects.extension_testpass.returns('.pass')
-    @tests_list.expects.pathmap('project/build/results/%n.pass').returns(@pass_results_list)
-
-    @test_invoker_helper.expects.clean_results({:force_run => true}, @fail_results_list, @pass_results_list)
-
-    @preprocessinator.expects.preprocess_tests_and_invoke_mocks(@tests_list).returns(@mocks_list)
-
-    @configurator.expects.project_test_runners_path.returns('project/build/runners')
-    @configurator.expects.test_runner_file_suffix.returns('_runner')
-    @tests_list.expects.pathmap('project/build/runners/%n_runner%x').returns(@runners_list)
-
-    @task_invoker.expects.invoke_runners(@runners_list)
-
-    @test_invoker_helper.expects.process_deep_dependencies(@tests_list, @mocks_list, @runners_list)
-
-    @dependinator.expects.setup_test_executable_dependencies(@tests_list)
-
-    @task_invoker.expects.invoke_results(@pass_results_list)
-
-    @test_invoker.setup_and_invoke(['project/tests/TestIng.c', 'project/tests/TestIcular.c'])
-  end
-
-
-end
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'ceedling/test_invoker'
+
+
+class TestInvokerTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:test_invoker_helper, :configurator, :preprocessinator, :task_invoker, :dependinator, :file_wrapper)
+    create_mocks(:tests_list, :mocks_list, :runners_list, :pass_results_list, :fail_results_list)
+    @test_invoker = TestInvoker.new(objects)
+  end
+
+  def teardown
+  end
+    
+  
+  should "run tests" do
+    @file_wrapper.expects.instantiate_file_list(['project/tests/TestIng.c', 'project/tests/TestIcular.c']).returns(@tests_list)
+
+    @configurator.expects.project_test_results_path.returns('project/build/results')
+    @configurator.expects.extension_testfail.returns('.fail')
+    @tests_list.expects.pathmap('project/build/results/%n.fail').returns(@fail_results_list)
+    @configurator.expects.project_test_results_path.returns('project/build/results')
+    @configurator.expects.extension_testpass.returns('.pass')
+    @tests_list.expects.pathmap('project/build/results/%n.pass').returns(@pass_results_list)
+
+    @test_invoker_helper.expects.clean_results({:force_run => true}, @fail_results_list, @pass_results_list)
+
+    @preprocessinator.expects.preprocess_tests_and_invoke_mocks(@tests_list).returns(@mocks_list)
+
+    @configurator.expects.project_test_runners_path.returns('project/build/runners')
+    @configurator.expects.test_runner_file_suffix.returns('_runner')
+    @tests_list.expects.pathmap('project/build/runners/%n_runner%x').returns(@runners_list)
+
+    @task_invoker.expects.invoke_runners(@runners_list)
+
+    @test_invoker_helper.expects.process_deep_dependencies(@tests_list, @mocks_list, @runners_list)
+
+    @dependinator.expects.setup_test_executable_dependencies(@tests_list)
+
+    @task_invoker.expects.invoke_results(@pass_results_list)
+
+    @test_invoker.setup_and_invoke(['project/tests/TestIng.c', 'project/tests/TestIcular.c'])
+  end
+
+
+end

data/test_graveyard/unit/busted/tool_executor_helper_test.rb

@@ -1,100 +1,100 @@
-require File.dirname(__FILE__) + '/../unit_test_helper'
-require 'ceedling/tool_executor_helper'
-
-
-class ToolExecutorHelperTest < Test::Unit::TestCase
-
-  def setup
-    objects = create_mocks(:verbosinator, :stream_wrapper)
-    @tool_executor_helper = ToolExecutorHelper.new(objects)
-  end
-
-  def teardown
-  end
-  
-  
-  should "print no happy results" do
-    # non-zero (fail) exit code
-    shell_result = {:output => 'la la la. connect the dots.', :exit_code => 1}
-    @tool_executor_helper.print_happy_results("", shell_result)
-
-    # zero exit code but insufficent verbosity settings
-    shell_result = {:output => "pee wee's playhouse", :exit_code => 0}
-    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(false)
-    @tool_executor_helper.print_happy_results("tool.exe", shell_result)
-  end
-
-  should "print happy results with response" do
-    # zero exit code (success) and sufficent verbosity settings
-    shell_result = {:output => "gcc blather", :exit_code => 0}
-    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(true)
-    
-    @stream_wrapper.expects.stdout_puts("> Shell executed command:")
-    @stream_wrapper.expects.stdout_puts("gcc -Iproject/source file.c -o file.out")
-    @stream_wrapper.expects.stdout_puts("> Produced response:")
-    @stream_wrapper.expects.stdout_puts("gcc blather")
-    @stream_wrapper.expects.stdout_puts('')
-    @stream_wrapper.expects.stdout_flush
-    
-    @tool_executor_helper.print_happy_results("gcc -Iproject/source file.c -o file.out", shell_result)
-  end
-
-  should "print happy results with no response" do
-    # zero exit code (success) and sufficent verbosity settings
-    shell_result = {:output => "", :exit_code => 0}
-    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(true)
-    
-    @stream_wrapper.expects.stdout_puts("> Shell executed command:")
-    @stream_wrapper.expects.stdout_puts("gcc -Iproject/source file.c -o file.out")
-    @stream_wrapper.expects.stdout_puts('')
-    @stream_wrapper.expects.stdout_flush
-    
-    @tool_executor_helper.print_happy_results("gcc -Iproject/source file.c -o file.out", shell_result)
-  end
-
-
-  should "print no error results" do
-    # zero (success) exit code
-    shell_result = {:output => 'here he comes to save the day!', :exit_code => 0}
-    @tool_executor_helper.print_error_results("", shell_result)
-
-    # non-zero exit code but insufficent verbosity settings
-    shell_result = {:output => "mighty mouse", :exit_code => 1}
-    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(false)
-    @tool_executor_helper.print_error_results("cmd.exe", shell_result)
-  end
-
-  should "print error results with response" do
-    # non-zero exit code (fail) and sufficent verbosity settings
-    shell_result = {:output => "coverage: 56%", :exit_code => 99}
-    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(true)
-    
-    @stream_wrapper.expects.stderr_puts("ERROR: Shell command failed.")
-    @stream_wrapper.expects.stderr_puts("> Shell executed command:")
-    @stream_wrapper.expects.stderr_puts("bullseye.exe project/build/output")
-    @stream_wrapper.expects.stderr_puts("> Produced response:")
-    @stream_wrapper.expects.stderr_puts("coverage: 56%")
-    @stream_wrapper.expects.stderr_puts("> And exited with status: [99].")
-    @stream_wrapper.expects.stderr_puts('')
-    @stream_wrapper.expects.stderr_flush
-    
-    @tool_executor_helper.print_error_results("bullseye.exe project/build/output", shell_result)
-  end
-
-  should "print error results with no response" do
-    # non-zero exit code (fail) and sufficent verbosity settings
-    shell_result = {:output => "", :exit_code => 21}
-    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(true)
-    
-    @stream_wrapper.expects.stderr_puts("ERROR: Shell command failed.")
-    @stream_wrapper.expects.stderr_puts("> Shell executed command:")
-    @stream_wrapper.expects.stderr_puts("bullseye.exe project/build/output")
-    @stream_wrapper.expects.stderr_puts("> And exited with status: [21].")
-    @stream_wrapper.expects.stderr_puts('')
-    @stream_wrapper.expects.stderr_flush
-    
-    @tool_executor_helper.print_error_results("bullseye.exe project/build/output", shell_result)
-  end
-
-end
-
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'ceedling/tool_executor_helper'
+
+
+class ToolExecutorHelperTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:verbosinator, :stream_wrapper)
+    @tool_executor_helper = ToolExecutorHelper.new(objects)
+  end
+
+  def teardown
+  end
+  
+  
+  should "print no happy results" do
+    # non-zero (fail) exit code
+    shell_result = {:output => 'la la la. connect the dots.', :exit_code => 1}
+    @tool_executor_helper.print_happy_results("", shell_result)
+
+    # zero exit code but insufficent verbosity settings
+    shell_result = {:output => "pee wee's playhouse", :exit_code => 0}
+    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(false)
+    @tool_executor_helper.print_happy_results("tool.exe", shell_result)
+  end
+
+  should "print happy results with response" do
+    # zero exit code (success) and sufficent verbosity settings
+    shell_result = {:output => "gcc blather", :exit_code => 0}
+    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(true)
+    
+    @stream_wrapper.expects.stdout_puts("> Shell executed command:")
+    @stream_wrapper.expects.stdout_puts("gcc -Iproject/source file.c -o file.out")
+    @stream_wrapper.expects.stdout_puts("> Produced response:")
+    @stream_wrapper.expects.stdout_puts("gcc blather")
+    @stream_wrapper.expects.stdout_puts('')
+    @stream_wrapper.expects.stdout_flush
+    
+    @tool_executor_helper.print_happy_results("gcc -Iproject/source file.c -o file.out", shell_result)
+  end
+
+  should "print happy results with no response" do
+    # zero exit code (success) and sufficent verbosity settings
+    shell_result = {:output => "", :exit_code => 0}
+    @verbosinator.expects.should_output?(Verbosity::OBNOXIOUS).returns(true)
+    
+    @stream_wrapper.expects.stdout_puts("> Shell executed command:")
+    @stream_wrapper.expects.stdout_puts("gcc -Iproject/source file.c -o file.out")
+    @stream_wrapper.expects.stdout_puts('')
+    @stream_wrapper.expects.stdout_flush
+    
+    @tool_executor_helper.print_happy_results("gcc -Iproject/source file.c -o file.out", shell_result)
+  end
+
+
+  should "print no error results" do
+    # zero (success) exit code
+    shell_result = {:output => 'here he comes to save the day!', :exit_code => 0}
+    @tool_executor_helper.print_error_results("", shell_result)
+
+    # non-zero exit code but insufficent verbosity settings
+    shell_result = {:output => "mighty mouse", :exit_code => 1}
+    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(false)
+    @tool_executor_helper.print_error_results("cmd.exe", shell_result)
+  end
+
+  should "print error results with response" do
+    # non-zero exit code (fail) and sufficent verbosity settings
+    shell_result = {:output => "coverage: 56%", :exit_code => 99}
+    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(true)
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Shell command failed.")
+    @stream_wrapper.expects.stderr_puts("> Shell executed command:")
+    @stream_wrapper.expects.stderr_puts("bullseye.exe project/build/output")
+    @stream_wrapper.expects.stderr_puts("> Produced response:")
+    @stream_wrapper.expects.stderr_puts("coverage: 56%")
+    @stream_wrapper.expects.stderr_puts("> And exited with status: [99].")
+    @stream_wrapper.expects.stderr_puts('')
+    @stream_wrapper.expects.stderr_flush
+    
+    @tool_executor_helper.print_error_results("bullseye.exe project/build/output", shell_result)
+  end
+
+  should "print error results with no response" do
+    # non-zero exit code (fail) and sufficent verbosity settings
+    shell_result = {:output => "", :exit_code => 21}
+    @verbosinator.expects.should_output?(Verbosity::ERRORS).returns(true)
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Shell command failed.")
+    @stream_wrapper.expects.stderr_puts("> Shell executed command:")
+    @stream_wrapper.expects.stderr_puts("bullseye.exe project/build/output")
+    @stream_wrapper.expects.stderr_puts("> And exited with status: [21].")
+    @stream_wrapper.expects.stderr_puts('')
+    @stream_wrapper.expects.stderr_flush
+    
+    @tool_executor_helper.print_error_results("bullseye.exe project/build/output", shell_result)
+  end
+
+end
+

data/test_graveyard/unit/busted/tool_executor_test.rb

@@ -1,351 +1,351 @@
-require File.dirname(__FILE__) + '/../unit_test_helper'
-require 'ceedling/tool_executor'
-require 'yaml'
-
-
-NIL_GLOBAL_CONSTANT = nil
-
-class ToolExecutorTest < Test::Unit::TestCase
-
-  def setup
-    objects = create_mocks(:configurator, :tool_executor_helper, :streaminator, :system_wrapper)
-    @tool_executor = ToolExecutor.new(objects)
-  end
-
-  def teardown
-  end
-  
-
-  ######## Build Command Line #########
-
-  should "build a command line that contains only an executable if no arguments or blank arguments provided" do
-    
-    yaml1 = %Q[
-    :tool1:
-      :name: test_compiler
-      :executable: tool.exe
-      :arguments:
-    ].left_margin(0)
-    config1 = YAML.load(yaml1)
-
-    yaml2 = %Q[
-    :tool2:
-      :name: test_compiler
-      :executable: tool.exe
-      :arguments:
-        -
-        - ' '
-    ].left_margin(0)
-    config2 = YAML.load(yaml2)
-    
-    assert_equal('tool.exe', @tool_executor.build_command_line(config1[:tool1]))
-    assert_equal('tool.exe', @tool_executor.build_command_line(config2[:tool2]))
-  end
-
-
-  should "build a command line where the executable is specified by argument parameter input replacement" do
-    
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: ${1}
-      :arguments:
-        - '> ${2}'
-    ].left_margin(0)
-    config = YAML.load(yaml)
-    
-    assert_equal(
-      'a_tool > files/build/tmp/file.out',
-      @tool_executor.build_command_line(config[:tool], 'a_tool', 'files/build/tmp/file.out'))
-      
-    assert_equal(
-      'test.exe > results.out',
-      @tool_executor.build_command_line(config[:tool], 'test.exe', 'results.out'))      
-  end
-
-
-  should "build a command line where the executable is specified by argument parameter input replacement and ruby string substitution" do
-
-    # use funky string construction to prevent ruby from performing actual string substitution we're simulating
-    filepath_string = "\#{" + "File.join(A_PATH, '${2}'}"
-    
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: ${1}
-      :arguments:
-        - "> #{filepath_string}"
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    @system_wrapper.expects.eval("> \#{" + "File.join(A_PATH, 'file.out'}").returns('> files/build/tmp/file.out')
-    @system_wrapper.expects.eval("> \#{" + "File.join(A_PATH, 'results.out'}").returns('> files/build/tmp/results.out')
-    
-    assert_equal(
-      'a_tool > files/build/tmp/file.out',
-      @tool_executor.build_command_line(config[:tool], 'a_tool', 'file.out'))
-      
-    assert_equal(
-      'test.exe > files/build/tmp/results.out',
-      @tool_executor.build_command_line(config[:tool], 'test.exe', 'results.out'))      
-  end
-
-
-  should "complain when building a command line if tool executable is specified with a replacement parameter but referenced input is nil" do
-    
-    yaml = %Q[
-    :tool:
-      :name: tool_sample
-      :executable: ${1}
-      :arguments: []
-    ].left_margin(0)
-    config = YAML.load(yaml)
-    
-    @streaminator.expects.stderr_puts("ERROR: Tool 'tool_sample' expected valid argument data to accompany replacement operator ${1}.", Verbosity::ERRORS)
-    
-    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool], nil) }
-  end
-
-
-  should "build a command line from simple arguments and global constants using generic '$' string replacement indicator" do
-    
-    redefine_global_constant('DEFINES_TEST', ['WALDORF', 'STATLER'])
-    redefine_global_constant('COLLECTION_ALL_INCLUDE_PATHS', ['files/include', 'lib/modules/include'])
-    redefine_global_constant('PROJECT_BUILD_ROOT', 'project/files/tests/build')
-    
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: hecklers.exe
-      :arguments:
-        - '--dlib_config config.h'
-        - -D$: DEFINES_TEST
-        - --no_cse
-        - -I"$": COLLECTION_ALL_INCLUDE_PATHS
-        - -I"$/mocks": PROJECT_BUILD_ROOT
-        - --no_unroll
-    ].left_margin(0)
-    config = YAML.load(yaml)
-    
-    command_line = 'hecklers.exe --dlib_config config.h -DWALDORF -DSTATLER --no_cse -I"files/include" -I"lib/modules/include" -I"project/files/tests/build/mocks" --no_unroll'
-    
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
-  end
-
-
-  should "build a command line from simple arguments and inline yaml arrays using '$' string replacement indicator" do
-
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: compiler.exe
-      :arguments:
-        - --no_cse
-        - '--D $':
-          - DIFFERENT_DEFINE
-          - STILL_ANOTHER_DEFINE
-        - $:
-          - A
-          - B
-        - --a_setting
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    command_line = 'compiler.exe --no_cse --D DIFFERENT_DEFINE --D STILL_ANOTHER_DEFINE A B --a_setting'
-
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
-  end
-
-
-  should "build a command line with duplicates in argument array" do
-
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: compiler.exe
-      :arguments:
-        - ${1}
-        - --option1
-        - --option1
-        - '-D $':
-          - DEFINE_A
-          - DEFINE_A
-        - $:
-          - Z
-          - Z
-        - ${1}
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    command_line = 'compiler.exe arg --option1 --option1 -D DEFINE_A -D DEFINE_A Z Z arg'
-
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], 'arg'))
-  end
-
-
-  should "build a command line using ruby string substitution for simple arguments and '$' string replacement" do
-
-    # use funky string construction to prevent ruby from performing actual string substitution we're simulating
-    abc_string = "-\#{" + "['a', 'b', 'c'].join}"
-    num_string = "\#{" + "s = String.new; (1..9).to_a.each {|val| s += val.to_s}}"
-    sym_string = "\#{" + "\'*!~\'.reverse}"
-
-    @system_wrapper.expects.eval(abc_string).returns('-abc')
-    @system_wrapper.expects.eval(num_string).returns('123456789')
-    @system_wrapper.expects.eval(sym_string).returns('~!*')
-
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: compiler.exe
-      :arguments:
-        - "#{abc_string}"
-        - '--i $': "#{num_string}"
-        - '--o $':
-          - "#{sym_string}"
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    command_line = 'compiler.exe -abc --i 123456789 --o ~!*'
-
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
-  end
-
-
-  should "build a command line from simple arguments (including non-strings), inline yaml arrays, and input/output specifiers using string replacement indicators" do
-
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: compiler.exe
-      :arguments:
-        - --no_cse
-        - '-flag-${3}'
-        - ${1}
-        - '-D$':
-          - ELIGHT
-          - ELICIOUS
-        - '-verbose:${4}'
-        - '-o ${2}'
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    command_line = 'compiler.exe --no_cse -flag-1 -flag-2 process_me.c me_too.c and_me_also.c -DELIGHT -DELICIOUS -verbose:5 -o processed.o'
-
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], ['process_me.c', 'me_too.c', 'and_me_also.c'], 'processed.o', [1, 2], 5))
-  end
-
-
-  should "build a command line without replacing an escaped string replacement indicator" do
-
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: program
-      :arguments:
-        - --cse=\\$abc
-        - '-\\$D$':
-          - ELIGHT
-          - ELICIOUS
-        - '-o ${2}.\\$'
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    command_line = 'program --cse=$abc -$DELIGHT -$DELICIOUS -o processed1.$ -o processed2.$'
-
-    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], nil, ['processed1', 'processed2']))
-  end
-
-
-  should "complain when building a command line if a referenced constant is nil" do
-    
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: tool.exe
-      :arguments:
-        - -x$: NIL_GLOBAL_CONSTANT
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    @streaminator.expects.stderr_puts("ERROR: Tool 'test_compiler' found constant 'NIL_GLOBAL_CONSTANT' to be nil.", Verbosity::ERRORS)
-
-    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool]) }  
-  end
-
-
-  should "complain when building a command line if expansion elements are nil" do
-    
-    yaml = %Q[
-    :tool:
-      :name: test_compiler
-      :executable: tool.exe
-      :arguments:
-        - -x$:
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    @streaminator.expects.stderr_puts("ERROR: Tool 'test_compiler' could not expand nil elements for format string '-x$'.", Verbosity::ERRORS)
-
-    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool]) }  
-  end
-
-
-  should "complain when building a command line if argument replacement parameters are specified but referenced input is nil" do
-    
-    yaml = %Q[
-    :tool:
-      :name: classic_movie
-      :executable: harry
-      :arguments:
-        - ${1}
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    @streaminator.expects.stderr_puts("ERROR: Tool 'classic_movie' expected valid argument data to accompany replacement operator ${1}.", Verbosity::ERRORS)
-    
-    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool], nil, 'sally') }  
-  end
-
-  
-  should "complain when building a command line if argument replacement parameters are specified but no optional arguments are given" do
-    
-    yaml = %Q[
-    :tools_a_tool:
-      :name: take_a_dip_in_the_tool
-      :executable: harry
-      :arguments:
-        - ${2}
-    ].left_margin(0)
-    config = YAML.load(yaml)
-
-    @streaminator.expects.stderr_puts("ERROR: Tool 'take_a_dip_in_the_tool' expected valid argument data to accompany replacement operator ${2}.", Verbosity::ERRORS)
-    
-    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tools_a_tool]) }  
-  end
-
-  ######## Shell Out & Execute Command #########
-
-  should "shell out & execute command with additional arguments" do
-    shell_result = {:output => 'stdout string', :exit_code => 0}
-    
-    @system_wrapper.expects.shell_execute('shell_command arg1 arg2').returns(shell_result)
-  
-    @tool_executor_helper.expects.print_happy_results('shell_command arg1 arg2', shell_result)
-    @tool_executor_helper.expects.print_error_results('shell_command arg1 arg2', shell_result)
-  
-    assert_equal('stdout string', @tool_executor.exec(' shell_command', ['arg1', 'arg2']))
-  end
-
-  should "shell out & execute command but raise on non-zero exit code" do
-    shell_result = {:output => '', :exit_code => 1}
-    
-    @system_wrapper.expects.shell_execute('shell_fish').returns(shell_result)
-  
-    @tool_executor_helper.expects.print_happy_results('shell_fish', shell_result)
-    @tool_executor_helper.expects.print_error_results('shell_fish', shell_result)
-  
-    assert_raise(RuntimeError){ @tool_executor.exec('shell_fish') }
-  end
-
-end
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'ceedling/tool_executor'
+require 'yaml'
+
+
+NIL_GLOBAL_CONSTANT = nil
+
+class ToolExecutorTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator, :tool_executor_helper, :streaminator, :system_wrapper)
+    @tool_executor = ToolExecutor.new(objects)
+  end
+
+  def teardown
+  end
+  
+
+  ######## Build Command Line #########
+
+  should "build a command line that contains only an executable if no arguments or blank arguments provided" do
+    
+    yaml1 = %Q[
+    :tool1:
+      :name: test_compiler
+      :executable: tool.exe
+      :arguments:
+    ].left_margin(0)
+    config1 = YAML.load(yaml1)
+
+    yaml2 = %Q[
+    :tool2:
+      :name: test_compiler
+      :executable: tool.exe
+      :arguments:
+        -
+        - ' '
+    ].left_margin(0)
+    config2 = YAML.load(yaml2)
+    
+    assert_equal('tool.exe', @tool_executor.build_command_line(config1[:tool1]))
+    assert_equal('tool.exe', @tool_executor.build_command_line(config2[:tool2]))
+  end
+
+
+  should "build a command line where the executable is specified by argument parameter input replacement" do
+    
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: ${1}
+      :arguments:
+        - '> ${2}'
+    ].left_margin(0)
+    config = YAML.load(yaml)
+    
+    assert_equal(
+      'a_tool > files/build/tmp/file.out',
+      @tool_executor.build_command_line(config[:tool], 'a_tool', 'files/build/tmp/file.out'))
+      
+    assert_equal(
+      'test.exe > results.out',
+      @tool_executor.build_command_line(config[:tool], 'test.exe', 'results.out'))      
+  end
+
+
+  should "build a command line where the executable is specified by argument parameter input replacement and ruby string substitution" do
+
+    # use funky string construction to prevent ruby from performing actual string substitution we're simulating
+    filepath_string = "\#{" + "File.join(A_PATH, '${2}'}"
+    
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: ${1}
+      :arguments:
+        - "> #{filepath_string}"
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    @system_wrapper.expects.eval("> \#{" + "File.join(A_PATH, 'file.out'}").returns('> files/build/tmp/file.out')
+    @system_wrapper.expects.eval("> \#{" + "File.join(A_PATH, 'results.out'}").returns('> files/build/tmp/results.out')
+    
+    assert_equal(
+      'a_tool > files/build/tmp/file.out',
+      @tool_executor.build_command_line(config[:tool], 'a_tool', 'file.out'))
+      
+    assert_equal(
+      'test.exe > files/build/tmp/results.out',
+      @tool_executor.build_command_line(config[:tool], 'test.exe', 'results.out'))      
+  end
+
+
+  should "complain when building a command line if tool executable is specified with a replacement parameter but referenced input is nil" do
+    
+    yaml = %Q[
+    :tool:
+      :name: tool_sample
+      :executable: ${1}
+      :arguments: []
+    ].left_margin(0)
+    config = YAML.load(yaml)
+    
+    @streaminator.expects.stderr_puts("ERROR: Tool 'tool_sample' expected valid argument data to accompany replacement operator ${1}.", Verbosity::ERRORS)
+    
+    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool], nil) }
+  end
+
+
+  should "build a command line from simple arguments and global constants using generic '$' string replacement indicator" do
+    
+    redefine_global_constant('DEFINES_TEST', ['WALDORF', 'STATLER'])
+    redefine_global_constant('COLLECTION_ALL_INCLUDE_PATHS', ['files/include', 'lib/modules/include'])
+    redefine_global_constant('PROJECT_BUILD_ROOT', 'project/files/tests/build')
+    
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: hecklers.exe
+      :arguments:
+        - '--dlib_config config.h'
+        - -D$: DEFINES_TEST
+        - --no_cse
+        - -I"$": COLLECTION_ALL_INCLUDE_PATHS
+        - -I"$/mocks": PROJECT_BUILD_ROOT
+        - --no_unroll
+    ].left_margin(0)
+    config = YAML.load(yaml)
+    
+    command_line = 'hecklers.exe --dlib_config config.h -DWALDORF -DSTATLER --no_cse -I"files/include" -I"lib/modules/include" -I"project/files/tests/build/mocks" --no_unroll'
+    
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
+  end
+
+
+  should "build a command line from simple arguments and inline yaml arrays using '$' string replacement indicator" do
+
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: compiler.exe
+      :arguments:
+        - --no_cse
+        - '--D $':
+          - DIFFERENT_DEFINE
+          - STILL_ANOTHER_DEFINE
+        - $:
+          - A
+          - B
+        - --a_setting
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    command_line = 'compiler.exe --no_cse --D DIFFERENT_DEFINE --D STILL_ANOTHER_DEFINE A B --a_setting'
+
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
+  end
+
+
+  should "build a command line with duplicates in argument array" do
+
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: compiler.exe
+      :arguments:
+        - ${1}
+        - --option1
+        - --option1
+        - '-D $':
+          - DEFINE_A
+          - DEFINE_A
+        - $:
+          - Z
+          - Z
+        - ${1}
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    command_line = 'compiler.exe arg --option1 --option1 -D DEFINE_A -D DEFINE_A Z Z arg'
+
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], 'arg'))
+  end
+
+
+  should "build a command line using ruby string substitution for simple arguments and '$' string replacement" do
+
+    # use funky string construction to prevent ruby from performing actual string substitution we're simulating
+    abc_string = "-\#{" + "['a', 'b', 'c'].join}"
+    num_string = "\#{" + "s = String.new; (1..9).to_a.each {|val| s += val.to_s}}"
+    sym_string = "\#{" + "\'*!~\'.reverse}"
+
+    @system_wrapper.expects.eval(abc_string).returns('-abc')
+    @system_wrapper.expects.eval(num_string).returns('123456789')
+    @system_wrapper.expects.eval(sym_string).returns('~!*')
+
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: compiler.exe
+      :arguments:
+        - "#{abc_string}"
+        - '--i $': "#{num_string}"
+        - '--o $':
+          - "#{sym_string}"
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    command_line = 'compiler.exe -abc --i 123456789 --o ~!*'
+
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool]))
+  end
+
+
+  should "build a command line from simple arguments (including non-strings), inline yaml arrays, and input/output specifiers using string replacement indicators" do
+
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: compiler.exe
+      :arguments:
+        - --no_cse
+        - '-flag-${3}'
+        - ${1}
+        - '-D$':
+          - ELIGHT
+          - ELICIOUS
+        - '-verbose:${4}'
+        - '-o ${2}'
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    command_line = 'compiler.exe --no_cse -flag-1 -flag-2 process_me.c me_too.c and_me_also.c -DELIGHT -DELICIOUS -verbose:5 -o processed.o'
+
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], ['process_me.c', 'me_too.c', 'and_me_also.c'], 'processed.o', [1, 2], 5))
+  end
+
+
+  should "build a command line without replacing an escaped string replacement indicator" do
+
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: program
+      :arguments:
+        - --cse=\\$abc
+        - '-\\$D$':
+          - ELIGHT
+          - ELICIOUS
+        - '-o ${2}.\\$'
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    command_line = 'program --cse=$abc -$DELIGHT -$DELICIOUS -o processed1.$ -o processed2.$'
+
+    assert_equal(command_line, @tool_executor.build_command_line(config[:tool], nil, ['processed1', 'processed2']))
+  end
+
+
+  should "complain when building a command line if a referenced constant is nil" do
+    
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: tool.exe
+      :arguments:
+        - -x$: NIL_GLOBAL_CONSTANT
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    @streaminator.expects.stderr_puts("ERROR: Tool 'test_compiler' found constant 'NIL_GLOBAL_CONSTANT' to be nil.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool]) }  
+  end
+
+
+  should "complain when building a command line if expansion elements are nil" do
+    
+    yaml = %Q[
+    :tool:
+      :name: test_compiler
+      :executable: tool.exe
+      :arguments:
+        - -x$:
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    @streaminator.expects.stderr_puts("ERROR: Tool 'test_compiler' could not expand nil elements for format string '-x$'.", Verbosity::ERRORS)
+
+    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool]) }  
+  end
+
+
+  should "complain when building a command line if argument replacement parameters are specified but referenced input is nil" do
+    
+    yaml = %Q[
+    :tool:
+      :name: classic_movie
+      :executable: harry
+      :arguments:
+        - ${1}
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    @streaminator.expects.stderr_puts("ERROR: Tool 'classic_movie' expected valid argument data to accompany replacement operator ${1}.", Verbosity::ERRORS)
+    
+    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tool], nil, 'sally') }  
+  end
+
+  
+  should "complain when building a command line if argument replacement parameters are specified but no optional arguments are given" do
+    
+    yaml = %Q[
+    :tools_a_tool:
+      :name: take_a_dip_in_the_tool
+      :executable: harry
+      :arguments:
+        - ${2}
+    ].left_margin(0)
+    config = YAML.load(yaml)
+
+    @streaminator.expects.stderr_puts("ERROR: Tool 'take_a_dip_in_the_tool' expected valid argument data to accompany replacement operator ${2}.", Verbosity::ERRORS)
+    
+    assert_raise(RuntimeError) { @tool_executor.build_command_line(config[:tools_a_tool]) }  
+  end
+
+  ######## Shell Out & Execute Command #########
+
+  should "shell out & execute command with additional arguments" do
+    shell_result = {:output => 'stdout string', :exit_code => 0}
+    
+    @system_wrapper.expects.shell_execute('shell_command arg1 arg2').returns(shell_result)
+  
+    @tool_executor_helper.expects.print_happy_results('shell_command arg1 arg2', shell_result)
+    @tool_executor_helper.expects.print_error_results('shell_command arg1 arg2', shell_result)
+  
+    assert_equal('stdout string', @tool_executor.exec(' shell_command', ['arg1', 'arg2']))
+  end
+
+  should "shell out & execute command but raise on non-zero exit code" do
+    shell_result = {:output => '', :exit_code => 1}
+    
+    @system_wrapper.expects.shell_execute('shell_fish').returns(shell_result)
+  
+    @tool_executor_helper.expects.print_happy_results('shell_fish', shell_result)
+    @tool_executor_helper.expects.print_error_results('shell_fish', shell_result)
+  
+    assert_raise(RuntimeError){ @tool_executor.exec('shell_fish') }
+  end
+
+end