ceedling 0.0.1

data/new_project_template/vendor/ceedling/test/unit/busted/configurator_helper_test.rb

@@ -0,0 +1,234 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'configurator_helper'
+
+
+class ConfiguratorHelperTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator_validator, :system_wrapper)
+    @helper = ConfiguratorHelper.new(objects)
+    
+    @test_config = {}
+  end
+
+  def teardown
+  end
+
+
+  should "do nothing if no 'environment' entry in the yaml config" do
+    @helper.set_environment_variables(@test_config)
+  end
+
+  should "set environment variables from yaml config" do
+    @test_config[:environment] = {
+      :cov_file => 'project/artifacts/test.cov',
+      :TEST_NUMBER => 101,
+      :environment_var => -2
+      }
+
+    @system_wrapper.expects.env_set('TEST_NUMBER', '101')
+    @system_wrapper.expects.env_set('COV_FILE', 'project/artifacts/test.cov')
+    @system_wrapper.expects.env_set('ENVIRONMENT_VAR', '-2')
+
+    @helper.set_environment_variables(@test_config)
+  end
+
+
+  should "return true when all top-level configuration entries are present" do
+    @configurator_validator.expects.exists?(@test_config, :project).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools).returns(true)
+
+    assert(@helper.validate_required_sections(@test_config))
+  end
+
+  should "fail if any top-level configuration entries are missing" do
+    
+    @configurator_validator.expects.exists?(@test_config, :project).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :paths).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools).returns(true)
+
+    assert_equal(false, @helper.validate_required_sections(@test_config))
+    
+    @configurator_validator.expects.exists?(@test_config, :project).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :tools).returns(true)
+
+    assert_equal(false, @helper.validate_required_sections(@test_config))
+    
+    @configurator_validator.expects.exists?(@test_config, :project).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools).returns(false)
+
+    assert_equal(false, @helper.validate_required_sections(@test_config))
+
+    @configurator_validator.expects.exists?(@test_config, :project).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :paths).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools).returns(false)
+
+    assert_equal(false, @helper.validate_required_sections(@test_config))
+  end
+
+
+  should "return true when all required section values are present" do
+    @configurator_validator.expects.exists?(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :test).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :source).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_compiler).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_linker).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_fixture).returns(true)
+    
+    assert(@helper.validate_required_section_values(@test_config))
+  end
+
+  should "fail when any required section value is missing" do
+    @configurator_validator.expects.exists?(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :test).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :paths, :source).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_compiler).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_linker).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_fixture).returns(true)
+    
+    assert_equal(false, @helper.validate_required_section_values(@test_config))
+
+    @configurator_validator.expects.exists?(@test_config, :project, :build_root).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :paths, :test).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :source).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_compiler).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_linker).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_fixture).returns(true)
+    
+    assert_equal(false, @helper.validate_required_section_values(@test_config))
+
+    @configurator_validator.expects.exists?(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :test).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :paths, :source).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_compiler).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_linker).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :tools, :test_fixture).returns(false)
+    
+    assert_equal(false, @helper.validate_required_section_values(@test_config))
+  end
+
+
+  should "fail if any paths in the configuration fail validation" do
+    # note: source iterates through hash keys in string class's <=> order
+    @test_config[:paths] = {:paths1 => [], :paths2 => [], :paths3 => []}
+    @test_config[:plugins] = {:base_path => 'plugins', :enabled => ['boo', 'berry']}
+    
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(false)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(true)
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(true)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(true)
+    
+    assert_equal(false, @helper.validate_path_list(@test_config))
+
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(false)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(true)
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(true)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(true)
+    
+    assert_equal(false, @helper.validate_path_list(@test_config))
+
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(false)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(false)
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(true)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(true)
+    
+    assert_equal(false, @helper.validate_path_list(@test_config))
+
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(true)
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(false)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(true)
+    
+    assert_equal(false, @helper.validate_path_list(@test_config))
+
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(true)
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(true)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(false)
+    
+    assert_equal(false, @helper.validate_path_list(@test_config))
+  end
+
+  should "successfully validate all paths in the configuration" do
+    # note: source iterates through hash keys in string class's <=> order
+    @test_config[:paths] = {:paths1 => [], :paths2 => [], :paths3 => []}
+    @test_config[:plugins] = {:base_path => 'plugins', :enabled => ['boo', 'berry']}
+    
+    @configurator_validator.expects.validate_path_list(@test_config, :project, :build_root).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths1).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths2).returns(true)
+    @configurator_validator.expects.validate_path_list(@test_config, :paths, :paths3).returns(true)
+
+    @configurator_validator.expects.validate_path('plugins', :plugins, :base_path).returns(true)
+    @configurator_validator.expects.validate_path('plugins/berry', :plugins, :enabled, :berry).returns(true)
+    @configurator_validator.expects.validate_path('plugins/boo', :plugins, :enabled, :boo).returns(true)
+    
+    assert(@helper.validate_path_list(@test_config))
+  end
+
+
+  should "fail if any tools in the configuration fail validation" do
+    # note: source iterates through hash keys in string class's <=> order
+    @test_config[:tools] = {:circular_saw => {}, :compiler => {}, :report_generator => {}}
+    
+    @configurator_validator.expects.exists?(@test_config, :tools, :circular_saw, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :circular_saw, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :compiler, :executable).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :tools, :report_generator, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :report_generator, :executable).returns(true)
+    
+    assert_equal(false, @helper.validate_tools(@test_config))
+
+    @configurator_validator.expects.exists?(@test_config, :tools, :circular_saw, :executable).returns(false)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :circular_saw, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :compiler, :executable).returns(false)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :report_generator, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :report_generator, :executable).returns(true)
+    
+    assert_equal(false, @helper.validate_tools(@test_config))
+
+    @configurator_validator.expects.exists?(@test_config, :tools, :circular_saw, :executable).returns(false)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :circular_saw, :executable).returns(false)
+    @configurator_validator.expects.exists?(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :report_generator, :executable).returns(false)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :report_generator, :executable).returns(false)
+    
+    assert_equal(false, @helper.validate_tools(@test_config))
+  end
+
+  should "successfully validate tools in the configuration=" do
+    # note: source iterates through hash keys in string class's <=> order
+    @test_config[:tools] = {:circular_saw => {}, :compiler => {}, :report_generator => {}}
+    
+    @configurator_validator.expects.exists?(@test_config, :tools, :circular_saw, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :circular_saw, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :compiler, :executable).returns(true)
+    @configurator_validator.expects.exists?(@test_config, :tools, :report_generator, :executable).returns(true)
+    @configurator_validator.expects.validate_filepath(@test_config, :tools, :report_generator, :executable).returns(true)
+    
+    assert(@helper.validate_tools(@test_config))
+  end
+
+end

data/new_project_template/vendor/ceedling/test/unit/busted/configurator_test.rb

@@ -0,0 +1,232 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'configurator'
+
+
+class ConfiguratorTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:configurator_helper, :configurator_builder, :configurator_plugins, :yaml_wrapper)
+    create_mocks(:test_hash)
+    @configurator = Configurator.new(objects)
+    
+    @test_config = {}
+  end
+
+  def teardown
+  end
+
+
+  ############# verbosity ##############
+  
+  should "set project config and cmock config verbosity levels" do
+    assert_nil(@configurator.project_config_hash[:project_verbosity])
+    assert_nil(@configurator.cmock_config_hash[:verbosity])
+    
+    @configurator.set_verbosity(5)
+    
+    assert_equal(5, @configurator.project_config_hash[:project_verbosity])
+    assert_equal(5, @configurator.cmock_config_hash[:verbosity])
+  end
+  
+  ############# standardize paths #############
+  
+  should "standardize all paths" do
+    in_hash = {
+      :project => {:build_root => "files\\dir\\dir/"},
+      :paths => {
+        :yellow_brick => ["root\\subdir\\dir\\", "files/modules/tests", "source\\modules"],
+        :destruction => ["stuff/"]
+        },
+      :tools => {
+        :hammer => {:executable => "gcc"},
+        :ratchet => {:executable => "\\bin\\cpp"}
+        },
+      :plugins => {:base_path => "project\\plugins"}
+      }
+  
+    @configurator.standardize_paths(in_hash)
+  
+    assert_equal('files/dir/dir', in_hash[:project][:build_root])
+    
+    assert_equal(["root/subdir/dir", "files/modules/tests", "source/modules"], in_hash[:paths][:yellow_brick])
+    assert_equal(["stuff"], in_hash[:paths][:destruction])
+    
+    assert_equal('gcc', in_hash[:tools][:hammer][:executable])
+    assert_equal('/bin/cpp', in_hash[:tools][:ratchet][:executable])
+    
+    assert_equal('project/plugins', in_hash[:plugins][:base_path])
+  end
+  
+  ############# validate ##############
+
+  should "successfully validate configuration" do
+    @configurator_helper.expects.validate_required_sections(@test_config).returns(true)
+    @configurator_helper.expects.validate_required_section_values(@test_config).returns(true)
+    @configurator_helper.expects.validate_paths(@test_config).returns(true)
+    @configurator_helper.expects.validate_tools(@test_config).returns(true)
+    
+    @configurator.validate(@test_config)
+  end
+  
+  should "immediately raise if top-level configuration entries are missing" do
+    @configurator_helper.expects.validate_required_sections(@test_config).returns(false)
+    assert_raise(RuntimeError) { @configurator.validate(@test_config) }
+  end
+
+  should "validate everything and complain about section values" do
+    @configurator_helper.expects.validate_required_sections(@test_config).returns(true)
+    @configurator_helper.expects.validate_required_section_values(@test_config).returns(false)
+    @configurator_helper.expects.validate_paths(@test_config).returns(true)
+    @configurator_helper.expects.validate_tools(@test_config).returns(true)
+    
+    assert_raise(RuntimeError) { @configurator.validate(@test_config) }
+  end
+
+  should "validate everything and complain about paths" do
+    @configurator_helper.expects.validate_required_sections(@test_config).returns(true)
+    @configurator_helper.expects.validate_required_section_values(@test_config).returns(true)
+    @configurator_helper.expects.validate_paths(@test_config).returns(false)
+    @configurator_helper.expects.validate_tools(@test_config).returns(true)
+    
+    assert_raise(RuntimeError) { @configurator.validate(@test_config) }
+  end
+
+  should "validate everything and complain about tools" do
+    @configurator_helper.expects.validate_required_sections(@test_config).returns(true)
+    @configurator_helper.expects.validate_required_section_values(@test_config).returns(true)
+    @configurator_helper.expects.validate_paths(@test_config).returns(true)
+    @configurator_helper.expects.validate_tools(@test_config).returns(false)
+    
+    assert_raise(RuntimeError) { @configurator.validate(@test_config) }
+  end
+
+  ############# insert cmock defaults ##############
+
+  should "insert into provided config hash necessary default cmock settings" do
+    config = { # no :cmock parent
+      :project => {
+        :build_root => 'project/build',
+        :verbosity => 10
+        }
+      } 
+    
+    expected = {
+      :project => {
+        :build_root => 'project/build',
+        :verbosity => 10
+        },
+      :cmock => {
+        :mock_prefix => 'Mock',
+        :mock_path => 'project/build/tests/mocks',
+        :enforce_strict_ordering => true,
+        :verbosity => 10,
+        }
+      }
+    
+    @configurator.populate_cmock_defaults(config)
+    
+    assert_equal(expected, config)
+  end
+
+  should "not override cmock settings already in configuration hash" do
+    config = {
+      :project => {
+        :verbosity => 0
+        },
+      :cmock => {
+        :mock_prefix => 'mock_',
+        :mock_path => 'foo/bar/mocks',
+        :enforce_strict_ordering => false,
+        :verbosity => 3,
+        }
+      } 
+    
+    expected = config.clone
+    
+    @configurator.populate_cmock_defaults(config)
+    
+    assert_equal(expected, config)
+  end
+
+
+  ############# build configuration ##############
+      
+  should "build up configuration and constantize and create accessor methods from it" do
+    # prep before hashification
+    @configurator_builder.expects.populate_tool_names(@test_config)
+    
+    # set environment variables
+    @configurator_helper.expects.set_environment_variables(@test_config)
+    
+    # flattenify the config object
+    @configurator_builder.expects.flattenify(@test_config).returns(@test_hash)
+
+    # insert info into configuration
+    @configurator_builder.expects.populate_defaults(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+    
+    # do some housekeeping
+    @configurator_builder.expects.clean(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.set_build_paths(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.set_rakefile_components(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.collect_test_and_source_include_paths(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.collect_test_and_source_paths(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+    
+    # build up configuration
+    @configurator_builder.expects.collect_tests(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.collect_source(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.collect_headers(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # build up configuration
+    @configurator_builder.expects.collect_all_compilation_input(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+    
+    # build up configuration
+    @configurator_builder.expects.collect_test_defines(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+    
+    # build up configuration
+    @configurator_builder.expects.collect_code_generation_dependencies.returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+    
+    # expand paths
+    @configurator_builder.expects.expand_all_path_globs(@test_hash).returns(@test_hash)
+    @test_hash.expects.merge!(@test_hash).returns(@test_hash)
+
+    # provide mock hash with some keys and values to constantize & add accessor methods to configurator
+    @test_hash.expects.each_pair.yields([:test_key_1, 'test_val1'], [:test_key_2, ['foo', 'bar']])
+    @test_hash.expects(:[], :test_key_1).returns('test_val1')
+    @test_hash.expects(:[], :test_key_2).returns(['foo', 'bar'])
+    
+    assert_nil(defined?(TEST_KEY_1))
+    assert_nil(defined?(TEST_KEY_2))
+
+    @configurator.build(@test_config)
+    
+    assert_equal('test_val1', TEST_KEY_1)
+    assert_equal('test_val1', @configurator.test_key_1)
+    
+    assert_equal(['foo', 'bar'], TEST_KEY_2)
+    assert_equal(['foo', 'bar'], @configurator.test_key_2)
+  end
+
+end

data/new_project_template/vendor/ceedling/test/unit/busted/configurator_validator_test.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'configurator_validator'
+
+
+class ConfiguratorValidatorTest < Test::Unit::TestCase
+
+  def setup
+    objects = create_mocks(:file_wrapper, :stream_wrapper, :system_wrapper)
+    @validator = ConfiguratorValidator.new(objects)
+  end
+
+  def teardown
+  end
+  
+  ######### exists? ##########
+  
+  should "verify valid paths into config hash" do
+    # deeper than real config, but let's exercise it just for fun
+    config = {
+      :root => {
+        :level2 => {
+          :level3 => {
+            :value => 'well, hello there'
+      }}}}
+    
+    assert(@validator.exists?( config, :root ))
+    assert(@validator.exists?( config, :root, :level2 ))
+    assert(@validator.exists?( config, :root, :level2, :level3 ))
+    assert(@validator.exists?( config, :root, :level2, :level3, :value ))
+  end
+
+  should "complain about non-existent paths into config hash" do
+    # deeper than real config, but let's exercise it just for fun
+    config = {
+      :root => {
+        :level2 => {
+          :level3 => {
+            :value => 'well, hello there'
+      }}}}
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Required config file entry [:nope] does not exist.")
+    @stream_wrapper.expects.stderr_puts("ERROR: Required config file entry [:root][:sorry] does not exist.")
+    @stream_wrapper.expects.stderr_puts("ERROR: Required config file entry [:root][:level2][:no_can_do] does not exist.")
+    @stream_wrapper.expects.stderr_puts("ERROR: Required config file entry [:root][:level2][:level3][:wrong] does not exist.")
+    
+    assert_equal(false, @validator.exists?( config, :nope ))
+    assert_equal(false, @validator.exists?( config, :root, :sorry ))
+    assert_equal(false, @validator.exists?( config, :root, :level2, :no_can_do ))
+    assert_equal(false, @validator.exists?( config, :root, :level2, :level3, :wrong ))
+  end
+
+
+  ######### validate_path_list ##########
+  
+  should "fail for missing entries in config when validating path entries" do
+    config = {:project => {}}
+    
+    assert_equal(false, @validator.validate_path_list(config, :project, :build_root))
+  end
+  
+  should "complain about non-existent paths for given path entries in config" do
+    config = {:project => {:build_root => 'project/build'}}
+    
+    @file_wrapper.expects.exist?('project/build').returns(false)
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Config path [:project][:build_root]['project/build'] does not exist on disk.")
+    
+    assert_equal(false, @validator.validate_path_list(config, :project, :build_root))
+  end
+
+  should "successfully validate paths for given path entries in config" do
+    config = {
+      :project => {
+        :test_paths => ['main/test', 'modules/*/test']
+      }}
+  
+    @file_wrapper.expects.exist?('main/test').returns(true)
+    @file_wrapper.expects.exist?('modules').returns(true)
+        
+    assert(@validator.validate_path_list(config, :project, :test_paths))
+  end
+  
+  ######### validate_filepath ##########
+  
+  should "fail for missing entry in config when validating filepath" do
+    config = {
+      :tools => {
+        :thinger => {}
+      }}
+    
+    assert_equal(false, @validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+
+  should "complain about non-existent explicit filepath" do
+    config = {
+      :tools => {
+        :thinger => {
+          # specific path, check it
+          :executable => 'bin/app.exe'
+      }}}
+    
+    @file_wrapper.expects.exist?('bin/app.exe').returns(false)
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Config filepath [:tools][:thinger][:executable]['bin/app.exe'] does not exist on disk.") 
+    
+    assert_equal(false, @validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+
+  should "complain about non-existent filepath in search paths" do
+    config = {
+      :tools => {
+        :thinger => {
+          # specific path, check it
+          :executable => 'app'
+      }}}
+    
+      @system_wrapper.expects.search_paths.returns(['bin', 'c:/program files/app', 'tools/thingamabob'])
+
+      @file_wrapper.expects.exist?('bin/app').returns(false)
+      @file_wrapper.expects.exist?('c:/program files/app/app').returns(false)
+      @file_wrapper.expects.exist?('tools/thingamabob/app').returns(false)
+    
+    @stream_wrapper.expects.stderr_puts("ERROR: Config filepath [:tools][:thinger][:executable]['app'] does not exist in system search paths.") 
+    
+    assert_equal(false, @validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+
+  should "successfully validate filepath containing tool executor argument replacement" do
+    config = {
+      :tools => {
+        :thinger => {
+          # specific path, check it
+          :executable => '${11}'
+      }}}
+    
+    assert(@validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+
+  should "successfully validate explicit filepath" do
+    config = {
+      :tools => {
+        :thinger => {
+          # specific path, check it
+          :executable => 'bin/app.exe'
+      }}}
+    
+    @file_wrapper.expects.exist?('bin/app.exe').returns(true)
+    
+    assert(@validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+
+  should "successfully validate search path filepath" do
+    config = {
+      :tools => {
+        :thinger => {
+          # no path, go looking in search paths
+          :executable => 'gcc'
+      }}}
+    
+    @system_wrapper.expects.search_paths.returns(['/usr/bin', 'c:/program files/app', 'tools'])
+    
+    @file_wrapper.expects.exist?('/usr/bin/gcc').returns(false)
+    @file_wrapper.expects.exist?('c:/program files/app/gcc').returns(false)
+    @file_wrapper.expects.exist?('tools/gcc').returns(true)
+    
+    assert(@validator.validate_filepath(config, :tools, :thinger, :executable))
+  end
+  
+end