ceedling 0.0.1

data/new_project_template/vendor/ceedling/lib/rules_release.rake

@@ -0,0 +1,63 @@
+
+RELEASE_COMPILE_TASK_ROOT  = RELEASE_TASK_ROOT + 'compile:'
+RELEASE_ASSEMBLE_TASK_ROOT = RELEASE_TASK_ROOT + 'assemble:'
+
+
+if (RELEASE_BUILD_USE_ASSEMBLY)
+rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_ASM_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_assembly_file(task_name)
+    end  
+  ]) do |object|
+  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_ASSEMBLER, RELEASE_CONTEXT, object.source, object.name)
+end
+end
+
+
+rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_C_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_compilation_input_file(task_name)
+    end  
+  ]) do |object|
+  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_COMPILER, RELEASE_CONTEXT, object.source, object.name)
+end
+
+
+rule(/#{PROJECT_RELEASE_BUILD_TARGET}/) do |bin_file|
+  @ceedling[:generator].generate_executable_file(TOOLS_RELEASE_LINKER, RELEASE_CONTEXT, bin_file.prerequisites, bin_file.name)
+end
+
+
+namespace RELEASE_CONTEXT do
+  # use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+
+  namespace :compile do
+    rule(/^#{RELEASE_COMPILE_TASK_ROOT}\S+#{'\\'+EXTENSION_SOURCE}$/ => [ # compile task names by regex
+        proc do |task_name|
+          source = task_name.sub(/#{RELEASE_COMPILE_TASK_ROOT}/, '')
+          @ceedling[:file_finder].find_source_file(source, :error)
+        end
+    ]) do |compile|
+      @ceedling[:rake_wrapper][:directories].invoke
+      @ceedling[:project_config_manager].process_release_config_change
+      @ceedling[:release_invoker].setup_and_invoke_c_objects( [compile.source] )
+    end
+  end
+  
+  if (RELEASE_BUILD_USE_ASSEMBLY)
+  namespace :assemble do
+    rule(/^#{RELEASE_ASSEMBLE_TASK_ROOT}\S+#{'\\'+EXTENSION_ASSEMBLY}$/ => [ # assemble task names by regex
+        proc do |task_name|
+          source = task_name.sub(/#{RELEASE_ASSEMBLE_TASK_ROOT}/, '')
+          @ceedling[:file_finder].find_assembly_file(source)
+        end
+    ]) do |assemble|
+      @ceedling[:rake_wrapper][:directories].invoke
+      @ceedling[:project_config_manager].process_release_config_change
+      @ceedling[:release_invoker].setup_and_invoke_asm_objects( [assemble.source] )
+    end
+  end
+  end
+
+end
+

data/new_project_template/vendor/ceedling/lib/rules_release_aux_dependencies.rake

@@ -0,0 +1,15 @@
+
+
+rule(/#{PROJECT_RELEASE_DEPENDENCIES_PATH}\/#{'.+\\'+EXTENSION_DEPENDENCIES}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_compilation_input_file(task_name)
+    end  
+  ]) do |dep|
+  @ceedling[:generator].generate_dependencies_file(
+  	TOOLS_RELEASE_DEPENDENCIES_GENERATOR,
+  	RELEASE_CONTEXT,
+  	dep.source,
+  	@ceedling[:file_path_utils].form_release_build_c_object_filepath(dep.source),
+  	dep.name)
+end
+

data/new_project_template/vendor/ceedling/lib/rules_tests.rake

@@ -0,0 +1,49 @@
+
+
+rule(/#{PROJECT_TEST_FILE_PREFIX}#{'.+'+TEST_RUNNER_FILE_SUFFIX}#{'\\'+EXTENSION_SOURCE}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_test_input_for_runner_file(task_name)
+    end
+  ]) do |runner|
+  @ceedling[:generator].generate_test_runner(TEST_CONTEXT, runner.source, runner.name)
+end
+
+
+rule(/#{PROJECT_TEST_BUILD_OUTPUT_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_compilation_input_file(task_name)
+    end
+  ]) do |object|
+  @ceedling[:generator].generate_object_file(TOOLS_TEST_COMPILER, TEST_CONTEXT, object.source, object.name)
+end
+
+
+rule(/#{PROJECT_TEST_BUILD_OUTPUT_PATH}\/#{'.+\\'+EXTENSION_EXECUTABLE}$/) do |bin_file|
+  @ceedling[:generator].generate_executable_file(TOOLS_TEST_LINKER, TEST_CONTEXT, bin_file.prerequisites, bin_file.name)
+end
+
+
+rule(/#{PROJECT_TEST_RESULTS_PATH}\/#{'.+\\'+EXTENSION_TESTPASS}$/ => [
+    proc do |task_name|
+      @ceedling[:file_path_utils].form_test_executable_filepath(task_name)
+    end
+  ]) do |test_result|
+  @ceedling[:generator].generate_test_results(TOOLS_TEST_FIXTURE, TEST_CONTEXT, test_result.source, test_result.name)
+end
+
+
+namespace TEST_CONTEXT do
+  # use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+  
+  rule(/^#{TEST_TASK_ROOT}\S+$/ => [ # test task names by regex
+      proc do |task_name|
+        test = task_name.sub(/#{TEST_TASK_ROOT}/, '')
+        test = "#{PROJECT_TEST_FILE_PREFIX}#{test}" if not (test.start_with?(PROJECT_TEST_FILE_PREFIX))
+        @ceedling[:file_finder].find_test_from_file_path(test)
+      end
+  ]) do |test|
+    @ceedling[:rake_wrapper][:directories].invoke
+    @ceedling[:test_invoker].setup_and_invoke([test.source])
+  end
+end
+

data/new_project_template/vendor/ceedling/lib/rules_tests_aux_dependencies.rake

@@ -0,0 +1,15 @@
+
+
+rule(/#{PROJECT_TEST_DEPENDENCIES_PATH}\/#{'.+\\'+EXTENSION_DEPENDENCIES}$/ => [
+    proc do |task_name|
+      @ceedling[:file_finder].find_compilation_input_file(task_name)
+    end  
+  ]) do |dep|
+  @ceedling[:generator].generate_dependencies_file(
+  	TOOLS_TEST_DEPENDENCIES_GENERATOR,
+    TEST_CONTEXT,
+  	dep.source,
+  	@ceedling[:file_path_utils].form_test_build_object_filepath(dep.source),
+  	dep.name)
+end
+

data/new_project_template/vendor/ceedling/lib/setupinator.rb

@@ -0,0 +1,45 @@
+
+class Setupinator
+
+  attr_reader :config_hash
+  attr_writer :ceedling
+
+  def setup
+    @ceedling = {}
+    @config_hash = {}
+  end
+
+  def load_project_files
+    @ceedling[:project_file_loader].find_project_files
+    return @ceedling[:project_file_loader].load_project_config
+  end
+
+  def do_setup(config_hash)
+    @config_hash = config_hash
+
+    # load up all the constants and accessors our rake files, objects, & external scripts will need;
+    # note: configurator modifies the cmock section of the hash with a couple defaults to tie 
+    #       project together - the modified hash is used to build cmock object
+    @ceedling[:configurator].populate_defaults( config_hash )
+    @ceedling[:configurator].populate_unity_defines( config_hash )
+    @ceedling[:configurator].populate_cmock_defaults( config_hash )
+    @ceedling[:configurator].find_and_merge_plugins( config_hash )
+    @ceedling[:configurator].populate_tool_names_and_stderr_redirect( config_hash )
+    @ceedling[:configurator].eval_environment_variables( config_hash )
+    @ceedling[:configurator].eval_paths( config_hash )
+    @ceedling[:configurator].standardize_paths( config_hash )
+    @ceedling[:configurator].validate( config_hash )
+    @ceedling[:configurator].build( config_hash )
+    @ceedling[:configurator].insert_rake_plugins( @ceedling[:configurator].rake_plugins )
+    
+    @ceedling[:plugin_manager].load_plugin_scripts( @ceedling[:configurator].script_plugins, @ceedling )
+    @ceedling[:plugin_reportinator].set_system_objects( @ceedling )
+    @ceedling[:file_finder].prepare_search_sources
+    @ceedling[:loginator].setup_log_filepath
+    @ceedling[:project_config_manager].config_hash = config_hash
+  end
+
+  def reset_defaults(config_hash)
+    @ceedling[:configurator].reset_defaults( config_hash )
+  end
+end

data/new_project_template/vendor/ceedling/lib/stream_wrapper.rb

@@ -0,0 +1,20 @@
+
+class StreamWrapper
+
+  def stdout_puts(string)
+    $stdout.puts(string)
+  end
+
+  def stdout_flush
+    $stdout.flush
+  end
+  
+  def stderr_puts(string)
+    $stderr.puts(string)
+  end
+
+  def stderr_flush
+    $stderr.flush
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/streaminator.rb

@@ -0,0 +1,41 @@
+
+class Streaminator
+
+  require 'constants'
+
+  constructor :streaminator_helper, :verbosinator, :loginator, :stream_wrapper
+
+  # for those objects for whom the configurator has already been instantiated,
+  # Streaminator is a convenience object for handling verbosity and writing to the std streams
+
+  def stdout_puts(string, verbosity=Verbosity::NORMAL)
+    if (@verbosinator.should_output?(verbosity))
+      @stream_wrapper.stdout_puts(string)
+      @stream_wrapper.stdout_flush
+    end
+    
+    # write to log as though Verbosity::OBNOXIOUS
+    @loginator.log( string, @streaminator_helper.extract_name($stdout) )
+  end
+
+  def stderr_puts(string, verbosity=Verbosity::NORMAL)
+    if (@verbosinator.should_output?(verbosity))
+      @stream_wrapper.stderr_puts(string)
+      @stream_wrapper.stderr_flush
+    end
+
+    # write to log as though Verbosity::OBNOXIOUS
+    @loginator.log( string, @streaminator_helper.extract_name($stderr) )
+  end
+
+  def stream_puts(stream, string, verbosity=Verbosity::NORMAL)
+    if (@verbosinator.should_output?(verbosity))
+      stream.puts(string)
+      stream.flush
+    end
+
+    # write to log as though Verbosity::OBNOXIOUS
+    @loginator.log( string, @streaminator_helper.extract_name(stream) )
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/streaminator_helper.rb

@@ -0,0 +1,15 @@
+
+class StreaminatorHelper
+
+  def extract_name(stream)
+    name = case (stream.fileno)
+      when 0 then '#<IO:$stdin>'
+      when 1 then '#<IO:$stdout>'
+      when 2 then '#<IO:$stderr>'
+      else stream.inspect
+    end
+    
+    return name
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/system_wrapper.rb

@@ -0,0 +1,67 @@
+require 'rbconfig'
+
+class SystemWrapper
+
+  # static method for use in defaults
+  def self.is_windows?
+    return ((Config::CONFIG['host_os'] =~ /mswin|mingw/) ? true : false)
+  end
+
+  # class method so as to be mockable for tests
+  def is_windows?
+    return SystemWrapper.is_windows?
+  end
+  
+  def module_eval(string)
+    return Object.module_eval("\"" + string + "\"")
+  end
+
+  def eval(string)
+    return eval(string)
+  end
+
+  def search_paths
+    return ENV['PATH'].split(File::PATH_SEPARATOR)
+  end
+
+  def cmdline_args
+    return ARGV
+  end
+
+  def env_set(name, value)
+    ENV[name] = value
+  end
+  
+  def env_get(name)
+    return ENV[name]
+  end
+
+  def time_now
+    return Time.now.asctime
+  end
+
+  def shell_execute(command)
+    return {
+      :output =>  `#{command}`,
+      :exit_code => ($?.exitstatus)
+    }
+  end
+  
+  def add_load_path(path)
+    $LOAD_PATH.unshift(path)
+  end
+  
+  def require_file(path)
+    require(path)
+  end
+
+  def ruby_success
+    return ($!.nil? || $!.is_a?(SystemExit) && $!.success?)
+  end
+
+  def constants_include?(item)
+    # forcing to strings provides consistency across Ruby versions
+    return Object.constants.map{|constant| constant.to_s}.include?(item.to_s)
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/task_invoker.rb

@@ -0,0 +1,85 @@
+
+class TaskInvoker
+
+  constructor :dependinator, :rake_utils, :rake_wrapper
+
+  def setup
+    @test_regexs = [/^#{TEST_ROOT_NAME}:/]
+    @release_regexs = [/^#{RELEASE_ROOT_NAME}(:|$)/]
+  end
+  
+  def add_test_task_regex(regex)
+    @test_regexs << regex
+  end
+
+  def add_release_task_regex(regex)
+    @release_regexs << regex
+  end
+  
+  def test_invoked?
+    invoked = false
+    
+    @test_regexs.each do |regex|
+      invoked = true if (@rake_utils.task_invoked?(regex))
+      break if invoked
+    end
+    
+    return invoked
+  end
+  
+  def release_invoked?
+    invoked = false
+    
+    @release_regexs.each do |regex|
+      invoked = true if (@rake_utils.task_invoked?(regex))
+      break if invoked
+    end
+    
+    return invoked
+  end
+
+  def invoked?(regex)
+    return @rake_utils.task_invoked?(regex)
+  end
+
+  
+  def invoke_test_mocks(mocks)
+    @dependinator.enhance_mock_dependencies( mocks )
+    mocks.each { |mock| @rake_wrapper[mock].invoke }
+  end
+  
+  def invoke_test_runner(runner)
+    @dependinator.enhance_runner_dependencies( runner )
+    @rake_wrapper[runner].invoke
+  end
+
+  def invoke_test_shallow_include_lists(files)
+    @dependinator.enhance_shallow_include_lists_dependencies( files )
+    files.each { |file| @rake_wrapper[file].invoke }
+  end
+
+  def invoke_test_preprocessed_files(files)
+    @dependinator.enhance_preprocesed_file_dependencies( files )
+    files.each { |file| @rake_wrapper[file].invoke }
+  end
+
+  def invoke_test_dependencies_files(files)
+    @dependinator.enhance_dependencies_dependencies( files )
+    files.each { |file| @rake_wrapper[file].invoke }
+  end
+
+  def invoke_test_results(result)
+    @dependinator.enhance_results_dependencies( result )
+    @rake_wrapper[result].invoke
+  end
+
+
+  def invoke_release_dependencies_files(files)
+    files.each { |file| @rake_wrapper[file].invoke }
+  end
+  
+  def invoke_release_objects(objects)
+    objects.each { |object| @rake_wrapper[object].invoke }
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/tasks_base.rake

@@ -0,0 +1,104 @@
+require 'constants'
+require 'file_path_utils'
+
+
+desc "Display build environment version info."
+task :version do
+  tools = [
+      ['  Ceedling', CEEDLING_ROOT],
+      ['CException', File.join( CEEDLING_VENDOR, CEXCEPTION_ROOT_PATH)],
+      ['     CMock', File.join( CEEDLING_VENDOR, CMOCK_ROOT_PATH)],
+      ['     Unity', File.join( CEEDLING_VENDOR, UNITY_ROOT_PATH)],
+    ]
+  
+  tools.each do |tool|
+    name      = tool[0]
+    base_path = tool[1]
+    
+    version_string = @ceedling[:file_wrapper].read( File.join(base_path, 'release', 'version.info') ).strip
+    build_string   = @ceedling[:file_wrapper].read( File.join(base_path, 'release', 'build.info') ).strip
+    puts "#{name}:: #{version_string.empty? ? '#.#.' : (version_string + '.')}#{build_string.empty? ? '?' : build_string}"
+  end
+end
+
+
+desc "Set verbose output (silent:[#{Verbosity::SILENT}] - obnoxious:[#{Verbosity::OBNOXIOUS}])."
+task :verbosity, :level do |t, args|
+  verbosity_level = args.level.to_i
+  
+  if (PROJECT_USE_MOCKS)
+    # don't store verbosity level in setupinator's config hash, use a copy;
+    # otherwise, the input configuration will change and trigger entire project rebuilds
+    hash = @ceedling[:setupinator].config_hash[:cmock].clone
+    hash[:verbosity] = verbosity_level
+
+    @ceedling[:cmock_builder].manufacture( hash )  
+  end
+
+  @ceedling[:configurator].project_verbosity = verbosity_level
+
+  # control rake's verbosity with new setting
+  verbose( ((verbosity_level >= Verbosity::OBNOXIOUS) ? true : false) )
+end
+
+
+desc "Enable logging"
+task :logging do
+  @ceedling[:configurator].project_logging = true
+end
+
+
+# non advertised debug task
+task :debug do
+  Rake::Task[:verbosity].invoke(Verbosity::DEBUG)
+  Rake.application.options.trace = true
+  @ceedling[:configurator].project_debug = true
+end
+
+
+# non advertised sanity checking task
+task :sanity_checks, :level do |t, args|
+  check_level = args.level.to_i
+  @ceedling[:configurator].sanity_checks = check_level
+end
+
+
+# list expanded environment variables
+if (not COLLECTION_ENVIRONMENT.empty?)
+desc "List all configured environment variables."
+task :environment do
+  COLLECTION_ENVIRONMENT.each do |env|
+    env.each_key do |key|
+      name = key.to_s.upcase
+      puts " - #{name}: \"#{env[key]}\""
+    end
+  end  
+end
+end
+
+
+namespace :options do
+
+  COLLECTION_PROJECT_OPTIONS.each do |option_path|
+    option = File.basename(option_path, '.yml')
+
+    desc "Merge #{option} project options."
+    task option.downcase.to_sym do
+      @ceedling[:setupinator].reset_defaults( @ceedling[:setupinator].config_hash )
+      hash = @ceedling[:project_config_manager].merge_options( @ceedling[:setupinator].config_hash, option_path )
+      @ceedling[:setupinator].do_setup( hash )
+    end
+  end
+
+end
+
+
+# do not present task if there's no plugins
+if (not PLUGINS_ENABLED.empty?)
+desc "Execute plugin result summaries (no build triggering)."
+task :summary do
+	@ceedling[:plugin_manager].summary
+  puts "\nNOTE: Summaries may be out of date with project sources.\n\n"
+end
+end
+

data/new_project_template/vendor/ceedling/lib/tasks_filesystem.rake

@@ -0,0 +1,89 @@
+
+# rather than require 'rake/clean' & try to override, we replicate for finer control
+CLEAN   = Rake::FileList["**/*~", "**/*.bak"]
+CLOBBER = Rake::FileList.new
+
+CLEAN.clear_exclude.exclude { |fn| fn.pathmap("%f") == 'core' && File.directory?(fn) }
+
+CLEAN.include(File.join(PROJECT_TEST_BUILD_OUTPUT_PATH, '*'))
+CLEAN.include(File.join(PROJECT_TEST_RESULTS_PATH, '*'))
+CLEAN.include(File.join(PROJECT_TEST_DEPENDENCIES_PATH, '*'))
+CLEAN.include(File.join(PROJECT_RELEASE_BUILD_OUTPUT_PATH, '*'))
+
+CLOBBER.include(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, '**/*'))
+CLOBBER.include(File.join(PROJECT_BUILD_TESTS_ROOT, '**/*'))
+CLOBBER.include(File.join(PROJECT_BUILD_RELEASE_ROOT, '**/*'))
+CLOBBER.include(File.join(PROJECT_LOG_PATH, '**/*'))
+CLOBBER.include(File.join(PROJECT_TEMP_PATH, '**/*'))
+
+# because of cmock config, mock path can optionally exist apart from standard test build paths
+CLOBBER.include(File.join(CMOCK_MOCK_PATH, '*'))
+
+REMOVE_FILE_PROC = Proc.new { |fn| rm_r fn rescue nil }
+
+# redefine clean so we can override how it advertises itself
+desc "Delete all build artifacts and temporary products."
+task(:clean) do
+  # because :clean is a prerequisite for :clobber, intelligently display the progress message
+  if (not @ceedling[:task_invoker].invoked?(/^clobber$/))
+    @ceedling[:streaminator].stdout_puts("\nCleaning build artifacts...\n(For large projects, this task may take a long time to complete)\n\n")
+  end
+  CLEAN.each { |fn| REMOVE_FILE_PROC.call(fn) }
+end
+
+# redefine clobber so we can override how it advertises itself
+desc "Delete all generated files (and build artifacts)."
+task(:clobber => [:clean]) do
+  @ceedling[:streaminator].stdout_puts("\nClobbering all generated files...\n(For large projects, this task may take a long time to complete)\n\n")
+  CLOBBER.each { |fn| REMOVE_FILE_PROC.call(fn) }
+end
+
+
+PROJECT_BUILD_PATHS.each { |path| directory(path) }
+
+# create directories that hold build output and generated files & touching rebuild dependency sources
+task(:directories => PROJECT_BUILD_PATHS) { @ceedling[:dependinator].touch_force_rebuild_files }
+
+
+# list paths discovered at load time
+namespace :paths do
+  
+  paths = @ceedling[:setupinator].config_hash[:paths]
+  paths.each_key do |section|
+    name = section.to_s.downcase
+    path_list = Object.const_get("COLLECTION_PATHS_#{name.upcase}")
+    
+    if (path_list.size != 0)
+      desc "List all collected #{name} paths."
+      task(name.to_sym) { puts "#{name} paths:"; path_list.sort.each {|path| puts " - #{path}" } }
+    end
+  end
+  
+end
+
+
+# list files & file counts discovered at load time
+namespace :files do
+  
+  categories = [
+    ['test',   COLLECTION_ALL_TESTS],
+    ['source', COLLECTION_ALL_SOURCE],
+    ['header', COLLECTION_ALL_HEADERS]
+    ]
+  categories << ['assembly', COLLECTION_ALL_ASSEMBLY] if (RELEASE_BUILD_USE_ASSEMBLY)
+  
+  categories.each do |category|
+    name       = category[0]
+    collection = category[1]
+    
+    desc "List all collected #{name} files."
+    task(name.to_sym) do
+      puts "#{name} files:"
+      collection.sort.each { |filepath| puts " - #{filepath}" }
+      puts "file count: #{collection.size}"
+    end
+  end
+  
+end
+
+

data/new_project_template/vendor/ceedling/lib/tasks_release.rake

@@ -0,0 +1,22 @@
+require 'constants'
+require 'file_path_utils'
+
+
+desc "Build release target."
+task RELEASE_CONTEXT => [:directories] do
+  header = "Release build '#{File.basename(PROJECT_RELEASE_BUILD_TARGET)}'"
+  @ceedling[:streaminator].stdout_puts("\n\n#{header}\n#{'-' * header.length}")  
+  
+  core_objects  = []
+  extra_objects = @ceedling[:file_path_utils].form_release_build_c_objects_filelist( COLLECTION_RELEASE_ARTIFACT_EXTRA_LINK_OBJECTS )
+  
+  @ceedling[:project_config_manager].process_release_config_change
+  core_objects.concat( @ceedling[:release_invoker].setup_and_invoke_c_objects( COLLECTION_ALL_SOURCE ) )
+  
+  # if assembler use isn't enabled, COLLECTION_ALL_ASSEMBLY is empty array & nothing happens
+  core_objects.concat( @ceedling[:release_invoker].setup_and_invoke_asm_objects( COLLECTION_ALL_ASSEMBLY ) )
+  
+  file( PROJECT_RELEASE_BUILD_TARGET => (core_objects + extra_objects) )
+  Rake::Task[PROJECT_RELEASE_BUILD_TARGET].invoke
+end
+

data/new_project_template/vendor/ceedling/lib/tasks_tests.rake

@@ -0,0 +1,49 @@
+
+namespace TEST_CONTEXT do
+  
+  desc "Run all unit tests."
+  task :all => [:directories] do
+    @ceedling[:test_invoker].setup_and_invoke(COLLECTION_ALL_TESTS)
+  end
+
+  desc "Run single test ([*] real test or source file name, no path)."
+  task :* do
+    message = "\nOops! '#{TEST_ROOT_NAME}:*' isn't a real task. " +
+              "Use a real test or source file name (no path) in place of the wildcard.\n" +
+              "Example: rake #{TEST_ROOT_NAME}:foo.c\n\n"
+  
+    @ceedling[:streaminator].stdout_puts( message )
+  end
+  
+  desc "Run tests for changed files."
+  task :delta => [:directories] do
+    @ceedling[:test_invoker].setup_and_invoke(COLLECTION_ALL_TESTS, {:force_run => false})
+  end
+  
+  desc "Run tests by matching regular expression pattern."
+  task :pattern, [:regex] => [:directories] do |t, args|
+    matches = []
+    
+    COLLECTION_ALL_TESTS.each { |test| matches << test if (test =~ /#{args.regex}/) }
+  
+    if (matches.size > 0)
+      @ceedling[:test_invoker].setup_and_invoke(matches, {:force_run => false})
+    else
+      @ceedling[:streaminator].stdout_puts("\nFound no tests matching pattern /#{args.regex}/.")
+    end
+  end
+
+  desc "Run tests whose test path contains [dir] or [dir] substring."
+  task :path, [:dir] => [:directories] do |t, args|
+    matches = []
+    
+    COLLECTION_ALL_TESTS.each { |test| matches << test if File.dirname(test).include?(args.dir.gsub(/\\/, '/')) }
+  
+    if (matches.size > 0)
+      @ceedling[:test_invoker].setup_and_invoke(matches, {:force_run => false})
+    else
+      @ceedling[:streaminator].stdout_puts("\nFound no tests including the given path or path component.")
+    end
+  end
+  
+end