ceedling 0.0.1

data/new_project_template/vendor/ceedling/plugins/xml_tests_report/xml_tests_report.rb

@@ -0,0 +1,106 @@
+require 'plugin'
+require 'constants'
+
+class XmlTestsReport < Plugin
+
+  def setup
+    @file_path    = File.join( PROJECT_TEST_ARTIFACTS_PATH, 'report.xml' )
+    @results_list = []
+    @test_counter = 1
+  end
+
+  def post_test_execute(arg_hash)
+    return if not (arg_hash[:context] == TEST_TASKS_CONTEXT)
+
+    @results_list << arg_hash[:result_file]
+  end
+  
+  def post_build
+    return if (not @ceedling[:task_invoker].test_invoked?)
+    
+    results = @ceedling[:plugin_reportinator].assemble_test_results(@results_list)
+  
+    @ceedling[:file_wrapper].open( @file_path, 'w' ) do |f|
+      write_results( results, f )
+    end
+  end
+  
+  private
+  
+  def write_results( results, stream )
+    write_header( stream )
+    write_failures( results[:failures], stream )
+    write_tests( results[:successes], stream, 'SuccessfulTests' )
+    write_tests( results[:ignores], stream, 'IgnoredTests' )
+    write_statistics( results[:counts], stream )
+    write_footer( stream )
+  end
+  
+  def write_header( stream )
+    stream.puts "<?xml version='1.0' encoding='utf-8' ?>"
+    stream.puts "<TestRun>"
+  end
+
+  def write_failures( results, stream )
+    if (results.size == 0)
+      stream.puts "\t<FailedTests/>"
+      return
+    end
+
+    stream.puts "\t<FailedTests>"
+  
+    results.each do |result|
+        result[:collection].each do |item|
+          filename = File.join( result[:source][:path], result[:source][:file] )
+        
+          stream.puts "\t\t<Test id=\"#{@test_counter}\">"
+          stream.puts "\t\t\t<Name>#{filename}::#{item[:test]}</Name>"
+  				stream.puts "\t\t\t<FailureType>Assertion</FailureType>"
+          stream.puts "\t\t\t<Location>"
+          stream.puts "\t\t\t\t<File>#{filename}</File>"
+          stream.puts "\t\t\t\t<Line>#{item[:line]}</Line>"
+          stream.puts "\t\t\t</Location>"
+          stream.puts "\t\t\t<Message>#{item[:message]}</Message>"
+          stream.puts "\t\t</Test>"
+          @test_counter += 1
+        end
+    end
+    
+    stream.puts "\t</FailedTests>"      
+  end
+  
+  def write_tests( results, stream, tag )
+    if (results.size == 0)
+      stream.puts "\t<#{tag}/>"
+      return
+    end
+
+    stream.puts "\t<#{tag}>"
+  
+    results.each do |result|
+        result[:collection].each do |item|
+          stream.puts "\t\t<Test id=\"#{@test_counter}\">"
+          stream.puts "\t\t\t<Name>#{File.join( result[:source][:path], result[:source][:file] )}::#{item[:test]}</Name>"
+          stream.puts "\t\t</Test>"
+          @test_counter += 1
+        end
+    end
+    
+    stream.puts "\t</#{tag}>"      
+  end
+
+  def write_statistics( counts, stream )
+    stream.puts "\t<Statistics>"
+    stream.puts "\t\t<Tests>#{counts[:total]}</Tests>"
+    stream.puts "\t\t<Ignores>#{counts[:ignored]}</Ignores>"
+    stream.puts "\t\t<FailuresTotal>#{counts[:failed]}</FailuresTotal>"
+    stream.puts "\t\t<Errors>0</Errors>"
+    stream.puts "\t\t<Failures>#{counts[:failed]}</Failures>"
+    stream.puts "\t</Statistics>"
+  end
+  
+  def write_footer( stream )
+    stream.puts "</TestRun>"
+  end
+  
+end

data/new_project_template/vendor/ceedling/rakefile.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__)) + '/config/test_environment'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rakefile_helper'
+
+TEST_FILE_SUFFIX  = '_test.rb'
+TEST_FILE_PATTERN = "*#{TEST_FILE_SUFFIX}"
+
+include RakefileHelpers
+
+
+
+task :default => ['test:all']
+task :cruise  => [:default]
+
+
+unit_test_pattern           = "test/unit/#{TEST_FILE_PATTERN}"
+integrations_test_pattern   = "test/integration/#{TEST_FILE_PATTERN}"
+system_test_pattern         = "test/system/#{TEST_FILE_PATTERN}"
+
+ALL_UNIT_TESTS          = FileList[unit_test_pattern]
+ALL_INTEGRATION_TESTS   = FileList[integrations_test_pattern]
+ALL_SYSTEM_TESTS        = FileList[system_test_pattern]
+
+
+namespace :test do
+  desc "Run all unit, integration, and system tests"
+  task :all => ['test:unit:all']
+
+  Rake::TestTask.new('unit:all') do |t|
+    t.pattern = unit_test_pattern
+    t.verbose = true
+  end
+
+  namespace :unit do
+    create_test_tasks(ALL_UNIT_TESTS)
+  end
+
+  Rake::TestTask.new('integration:all') do |t|
+    t.pattern = integrations_test_pattern
+    t.verbose = true
+  end
+
+  namespace :integration do
+    create_test_tasks(ALL_INTEGRATION_TESTS)
+  end
+
+  Rake::TestTask.new('system:all') do |t|
+    t.pattern = system_test_pattern
+    t.verbose = true
+  end
+
+  namespace :system do
+    create_test_tasks(ALL_SYSTEM_TESTS)
+  end
+
+end
+

data/new_project_template/vendor/ceedling/rakefile_helper.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+require 'fileutils'
+
+module RakefileHelpers
+  
+  def report(message)
+    puts message
+    $stdout.flush
+    $stderr.flush
+  end
+
+  def create_test_tasks(test_list)
+    test_list.each do |test|
+      base_file = File.basename(test).gsub(/#{Regexp.escape(TEST_FILE_SUFFIX)}/, '')
+      desc base_file
+      Rake::TestTask.new(base_file) do |t|
+        t.test_files = [test]
+      end
+    end
+  end
+  
+end
+

data/new_project_template/vendor/ceedling/release/build.info

@@ -0,0 +1 @@
+157

data/new_project_template/vendor/ceedling/release/version.info

@@ -0,0 +1 @@
+0.9

data/new_project_template/vendor/ceedling/test/integration/paths.yml

@@ -0,0 +1,17 @@
+---
+:project:
+  :build_root: test/integration/paths/build
+
+:paths:
+  :test: []
+  :source: []
+  :include: []
+    
+:tools:
+  :test_compiler:
+    :executable: ''
+  :test_linker:
+    :executable: ''
+  :test_fixture:
+    :executable: ''
+...

data/new_project_template/vendor/ceedling/test/integration/paths_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../integration_test_helper'
+require 'rubygems'
+require 'rake' # for FileList
+require 'constructor'
+require 'file_system_utils'
+require 'file_wrapper'
+
+
+PATHS_ROOT = INTEGRATION_TEST_ROOT + '/paths'
+
+class PathsTest < Test::Unit::TestCase
+
+  def setup
+    ENV['CEEDLING_MAIN_PROJECT_FILE'] = File.join(INTEGRATION_TEST_ROOT, 'paths.yml')
+    
+    @file_system_utils = FileSystemUtils.new({:file_wrapper => FileWrapper.new})
+  end
+
+  def teardown
+  end
+
+
+  should "collect paths from file system and exercise globs and our special glob handling" do
+    # pass in two strings to find all test(s) dirs in main/ and modules/
+    expected = [
+      "#{PATHS_ROOT}/main/test",
+      "#{PATHS_ROOT}/modules/comm/ethernet/test",
+      "#{PATHS_ROOT}/modules/comm/serial/test",
+      "#{PATHS_ROOT}/modules/eeprom/test",
+      "#{PATHS_ROOT}/modules/display/tests",
+      "#{PATHS_ROOT}/modules/power/tests"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/main/test", "#{PATHS_ROOT}/modules/**/tes{t,ts}")
+    assert_equal(expected.sort, list.to_a.sort)
+    
+    # pass in a FileList to find all src/ dirs in all of PATHS_ROOT space
+    expected = [
+      "#{PATHS_ROOT}/main/src",
+      "#{PATHS_ROOT}/modules/comm/ethernet/src",
+      "#{PATHS_ROOT}/modules/comm/serial/src",
+      "#{PATHS_ROOT}/modules/display/src",
+      "#{PATHS_ROOT}/modules/eeprom/src",
+      "#{PATHS_ROOT}/modules/power/src"]   
+    list = @file_system_utils.collect_paths(FileList.new("#{PATHS_ROOT}/**/sr?"))
+    assert_equal(expected.sort, list.to_a.sort)
+
+    # pass in a string to recursively find all subdirectories below source/
+    expected = [
+      "#{PATHS_ROOT}/source/comm",
+      "#{PATHS_ROOT}/source/comm/ethernet",
+      "#{PATHS_ROOT}/source/comm/serial",
+      "#{PATHS_ROOT}/source/display",
+      "#{PATHS_ROOT}/source/eeprom",
+      "#{PATHS_ROOT}/source/power"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/source/**")
+    assert_equal(expected.sort, list.to_a.sort)
+
+    # pass in a string to find all subdirectories one level below source/
+    expected = [
+      "#{PATHS_ROOT}/source/comm",
+      "#{PATHS_ROOT}/source/display",
+      "#{PATHS_ROOT}/source/eeprom",
+      "#{PATHS_ROOT}/source/power"]
+    list = @file_system_utils.collect_paths("#{PATHS_ROOT}/source/*")
+    assert_equal(expected.sort, list.to_a.sort)
+
+
+    # pass in an array of strings to collect tests/ and all subdirectories below tests/
+    expected = [
+      "#{PATHS_ROOT}/tests",
+      "#{PATHS_ROOT}/tests/comm",
+      "#{PATHS_ROOT}/tests/comm/ethernet",
+      "#{PATHS_ROOT}/tests/comm/serial",
+      "#{PATHS_ROOT}/tests/display",
+      "#{PATHS_ROOT}/tests/eeprom",
+      "#{PATHS_ROOT}/tests/power"]
+    list = @file_system_utils.collect_paths(["#{PATHS_ROOT}/tests", "#{PATHS_ROOT}/tests/**"])
+    assert_equal(expected.sort, list.to_a.sort)
+  end
+
+end

data/new_project_template/vendor/ceedling/test/integration/rake_rules_aux_dependencies_test.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../integration_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesAuxDependenciesTest < Test::Unit::TestCase
+
+  def setup
+    rake_setup('rakefile_rules_aux_dependencies.rb', :file_finder, :generator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  should "recognize missing dependencies files, find their source, and execute rake tasks from the rule for dependency file generation" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_DEPENDENCIES_PATH', 'project/build/dependencies')
+    redefine_global_constant('EXTENSION_DEPENDENCIES', '.d')
+
+    # reload rakefile with new global constants
+    setup()
+
+    dependencies_src1 = 'files/source/thing.c'
+    dependencies_src2 = 'tests/test_thing.c'
+    dependencies_src3 = 'lib/stuff.c'
+    dependencies1     = 'project/build/dependencies/thing.d'
+    dependencies2     = 'project/build/dependencies/test_thing.d'
+    dependencies3     = 'project/build/dependencies/stuff.d'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, dependencies_src1)
+    @rake.define_task(Rake::FileTask, dependencies_src2)
+    @rake.define_task(Rake::FileTask, dependencies_src3)
+
+    # set up expectations
+    @file_finder.expects.find_compilation_input_file(dependencies1).returns(dependencies_src1)
+    @generator.expects.generate_dependencies_file(dependencies_src1, dependencies1)
+    @file_finder.expects.find_compilation_input_file(dependencies2).returns(dependencies_src2)
+    @generator.expects.generate_dependencies_file(dependencies_src2, dependencies2)
+    @file_finder.expects.find_compilation_input_file(dependencies3).returns(dependencies_src3)
+    @generator.expects.generate_dependencies_file(dependencies_src3, dependencies3)
+
+    # invoke the dependencies creation rule under test
+    @rake[dependencies1].invoke
+    @rake[dependencies2].invoke
+    @rake[dependencies3].invoke
+  end
+
+  should "handle alternate build file paths and file extensions for dependency file generation rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_DEPENDENCIES_PATH', 'dependencies/dump')
+    redefine_global_constant('EXTENSION_DEPENDENCIES', '.i')
+
+    # reload rakefile with new global constants
+    setup()
+
+    dependencies_src1 = 'files/source/thing.c'
+    dependencies1     = 'dependencies/dump/thing.i'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, dependencies_src1)
+
+    # set up expectations
+    @file_finder.expects.find_compilation_input_file(dependencies1).returns(dependencies_src1)
+    @generator.expects.generate_dependencies_file(dependencies_src1, dependencies1)
+
+    # invoke the dependencies creation rule under test
+    @rake[dependencies1].invoke
+  end
+
+end

data/new_project_template/vendor/ceedling/test/integration/rake_rules_cmock_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesCmockTest < Test::Unit::TestCase
+
+  def setup
+    rake_setup('rakefile_rules_cmock.rb', :file_finder, :generator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  should "recognize missing mock files, find their source, and execute rake tasks from the rule for mock generation" do
+    # default values as set in test_helper
+    redefine_global_constant('CMOCK_MOCK_PREFIX', 'mock_')
+    redefine_global_constant('EXTENSION_SOURCE', '.c')
+
+    # reload rakefile with new global constants
+    setup()
+
+    mock_src1 = 'files/source/thing.h'
+    mock_src2 = 'stuff.h'
+    mock_src3 = 'files/source/WooDoggie.h'
+    mock1     = 'files/mocks/mock_thing.c'
+    mock2     = 'mock_stuff.c'
+    mock3     = 'files/mocks/mock_WooDoggie.c'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, mock_src1)
+    @rake.define_task(Rake::FileTask, mock_src2)
+    @rake.define_task(Rake::FileTask, mock_src3)
+
+    # set up expectations
+    @file_finder.expects.find_mockable_header(mock1).returns(mock_src1)
+    @generator.expects.generate_mock(mock_src1)
+    @file_finder.expects.find_mockable_header(mock2).returns(mock_src2)
+    @generator.expects.generate_mock(mock_src2)
+    @file_finder.expects.find_mockable_header(mock3).returns(mock_src3)
+    @generator.expects.generate_mock(mock_src3)
+
+    # invoke the mock creation rule under test
+    @rake[mock1].invoke
+    @rake[mock2].invoke
+    @rake[mock3].invoke
+  end
+
+  should "handle alternate mock prefixes and source extensions for mock generation rule" do
+    redefine_global_constant('CMOCK_MOCK_PREFIX', 'Mock')
+    redefine_global_constant('EXTENSION_SOURCE', '.x')
+
+    # reload rakefile with new global constants
+    setup()
+
+    mock_src1 = 'files/source/IngBird.h'
+    mock1     = 'files/mocks/MockIngBird.x'
+
+    # fake out rake so it won't look for the header files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, mock_src1)
+
+    # set up expectations
+    @file_finder.expects.find_mockable_header(mock1).returns(mock_src1)
+    @generator.expects.generate_mock(mock_src1)
+
+    # invoke the mock creation rule under test
+    @rake[mock1].invoke
+  end
+
+end

data/new_project_template/vendor/ceedling/test/integration/rake_rules_preprocess_test.rb

@@ -0,0 +1,178 @@
+require File.dirname(__FILE__) + '/../unit_test_helper'
+require 'rubygems'
+require 'rake'
+
+
+class RakeRulesPreprocessTest < Test::Unit::TestCase
+
+  def setup    
+    rake_setup('rakefile_rules_preprocess.rb', :file_finder, :generator, :configurator)
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+  
+  
+  ################################
+  ####### Preprocess Files #######
+  ################################
+
+  should "recognize missing preprocessed files, find their source, and execute rake tasks from the rule for generating preprocessed file output" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    preprocess_src1 = 'tests/a/test_thing.c'
+    preprocess_src2 = 'source/a_file.h'
+    preprocess_src3 = 'source/lib/include/API.H'
+    preprocess1     = 'project/build/preprocess/files/test_thing.c'
+    preprocess2     = 'project/build/preprocess/files/a_file.h'
+    preprocess3     = 'project/build/preprocess/files/API.H'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+    @rake.define_task(Rake::FileTask, preprocess_src2)
+    @rake.define_task(Rake::FileTask, preprocess_src3)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_auxiliary_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src1)
+
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess2).returns(preprocess_src2)
+    @configurator.expects.project_use_auxiliary_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src2)
+
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess3).returns(preprocess_src3)
+    @configurator.expects.project_use_auxiliary_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src3)
+    
+    # invoke the test preprocess creation rule under test
+    @rake[preprocess1].invoke
+    @rake[preprocess2].invoke
+    @rake[preprocess3].invoke
+  end
+
+  should "complain if file preprocessing rule is executed but auxiliary dependencies are not enabled" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    preprocess_src1 = 'tests/a/test_thing.c'
+    preprocess1     = 'project/build/preprocess/files/test_thing.c'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_auxiliary_dependencies.returns(false)
+    
+    # invoke the test preprocess creation rule under test
+    assert_raise(RuntimeError){ @rake[preprocess1].invoke }
+  end
+
+  should "handle alternate output file paths for preprocessed file output rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'demacroified/files')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'includes')
+
+    # reload rakefile with new global constants
+    setup()
+
+    preprocess_src1 = 'tests/a/test_thing.C'
+    preprocess1     = 'demacroified/files/test_thing.C'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, preprocess_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(preprocess1).returns(preprocess_src1)
+    @configurator.expects.project_use_auxiliary_dependencies.returns(true)
+    @generator.expects.generate_preprocessed_file(preprocess_src1)
+
+    # invoke the test preprocess creation rule under test
+    @rake[preprocess1].invoke
+  end
+
+  ########################################
+  ####### Extract Shallow Includes #######
+  ########################################
+
+  should "recognize missing extracted includes files, find their source, and execute rake tasks from the rule for extracting file includes output" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'project/build/preprocess/includes')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+
+    # reload rakefile with new global constants
+    setup()
+
+    # try all different paths and file extensions; we should be able to preprocess any kind of source file
+    includes_src1 = 'tests/a/test_thing.c'
+    includes_src2 = 'source/a_file.h'
+    includes_src3 = 'source/lib/include/API.H'
+    includes1     = 'project/build/preprocess/includes/test_thing.c'
+    includes2     = 'project/build/preprocess/includes/a_file.h'
+    includes3     = 'project/build/preprocess/includes/API.H'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, includes_src1)
+    @rake.define_task(Rake::FileTask, includes_src2)
+    @rake.define_task(Rake::FileTask, includes_src3)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(includes1).returns(includes_src1)
+    @generator.expects.generate_shallow_includes_list(includes_src1)
+    @file_finder.expects.find_test_or_source_or_header_file(includes2).returns(includes_src2)
+    @generator.expects.generate_shallow_includes_list(includes_src2)
+    @file_finder.expects.find_test_or_source_or_header_file(includes3).returns(includes_src3)
+    @generator.expects.generate_shallow_includes_list(includes_src3)
+    
+    # invoke the test includes creation rule under test
+    @rake[includes1].invoke
+    @rake[includes2].invoke
+    @rake[includes3].invoke
+  end
+
+  should "handle alternate output file paths for preprocessor incluedes file output rule" do
+    # default values as set in test_helper
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_INCLUDES_PATH', 'include_stuff')
+    # because rule matches on any file, gotta set this path here to help rake distinguish rules when file is tested
+    redefine_global_constant('PROJECT_TEST_PREPROCESS_FILES_PATH', 'project/build/preprocess/files')
+
+    # reload rakefile with new global constants
+    setup()
+
+    includes_src1 = 'tests/a/test_thing.C'
+    includes1     = 'include_stuff/test_thing.C'
+  
+    # fake out rake so it won't look for the test files on disk and find they don't exist.
+    # by creating file tasks we're telling rake there's a means to create these files that don't exist (but we never use the mechanism).
+    @rake.define_task(Rake::FileTask, includes_src1)
+  
+    # set up expectations
+    @file_finder.expects.find_test_or_source_or_header_file(includes1).returns(includes_src1)
+    @generator.expects.generate_shallow_includes_list(includes_src1)
+    
+    # invoke the test includes creation rule under test
+    @rake[includes1].invoke
+  end
+
+end