dirty_history 0.1.3 → 0.2.0

data/dirty_history/ruby/1.9.1/gems/rake-0.9.2/test/test_rake_file_list_path_map.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeFileListPathMap < Rake::TestCase
+  def test_file_list_supports_pathmap
+    assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")
+  end
+end
+

data/dirty_history/ruby/1.9.1/gems/rake-0.9.2/test/test_rake_file_task.rb

@@ -0,0 +1,104 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+
+class TestRakeFileTask < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    Task.clear
+    @runs = Array.new
+    FileUtils.rm_f NEWFILE
+    FileUtils.rm_f OLDFILE
+  end
+
+  def test_file_need
+    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
+
+    name = "testdata/dummy"
+    file name
+
+    ftask = Task[name]
+
+    assert_equal name.to_s, ftask.name
+    File.delete(ftask.name) rescue nil
+
+    assert ftask.needed?, "file should be needed"
+
+    open(ftask.name, "w") { |f| f.puts "HI" }
+
+    assert_equal nil, ftask.prerequisites.collect{|n| Task[n].timestamp}.max
+    assert ! ftask.needed?, "file should not be needed"
+  ensure
+    File.delete(ftask.name) rescue nil
+  end
+
+  def test_file_times_new_depends_on_old
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = Rake.application.intern(FileTask, NEWFILE).enhance([OLDFILE])
+    t2 = Rake.application.intern(FileTask, OLDFILE)
+    assert ! t2.needed?, "Should not need to build old file"
+    assert ! t1.needed?, "Should not need to rebuild new file because of old"
+  end
+
+  def test_file_times_old_depends_on_new
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = Rake.application.intern(FileTask,OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileTask, NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    preq_stamp = t1.prerequisites.collect{|t| Task[t].timestamp}.max
+    assert_equal t2.timestamp, preq_stamp
+    assert t1.timestamp < preq_stamp, "T1 should be older"
+    assert t1.needed?, "Should need to rebuild old file because of new"
+  end
+
+  def test_file_depends_on_task_depend_on_file
+    create_timed_files(OLDFILE, NEWFILE)
+
+    file NEWFILE => [:obj] do |t| @runs << t.name end
+    task :obj => [OLDFILE] do |t| @runs << t.name end
+    file OLDFILE           do |t| @runs << t.name end
+
+    Task[:obj].invoke
+    Task[NEWFILE].invoke
+    assert ! @runs.include?(NEWFILE)
+  end
+
+  def test_existing_file_depends_on_non_existing_file
+    @ran = false
+
+    create_file(OLDFILE)
+    delete_file(NEWFILE)
+    file NEWFILE do
+      @ran = true
+    end
+
+    file OLDFILE => NEWFILE
+
+    Task[OLDFILE].invoke
+
+    assert @ran
+  end
+
+  # I have currently disabled this test.  I'm not convinced that
+  # deleting the file target on failure is always the proper thing to
+  # do.  I'm willing to hear input on this topic.
+  def ztest_file_deletes_on_failure
+    task :obj
+    file NEWFILE => [:obj] do |t|
+      FileUtils.touch NEWFILE
+      fail "Ooops"
+    end
+    assert Task[NEWFILE]
+    begin
+      Task[NEWFILE].invoke
+    rescue Exception
+    end
+    assert( ! File.exist?(NEWFILE), "NEWFILE should be deleted")
+  end
+
+end
+

data/dirty_history/ruby/1.9.1/gems/rake-0.9.2/test/test_rake_file_utils.rb

@@ -0,0 +1,252 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+
+class TestRakeFileUtils < Rake::TestCase
+
+  def setup
+    super
+
+    File.chmod(0750, "test/shellcommand.rb")
+  end
+
+  def teardown
+    File.chmod(0755, "test/shellcommand.rb")
+    FileUtils.rm_rf("testdata")
+    FileUtils::LN_SUPPORTED[0] = true
+
+    super
+  end
+
+  def test_rm_one_file
+    create_file("testdata/a")
+    FileUtils.rm_rf "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_rm_two_files
+    create_file("testdata/a")
+    create_file("testdata/b")
+    FileUtils.rm_rf ["testdata/a", "testdata/b"]
+    assert ! File.exist?("testdata/a")
+    assert ! File.exist?("testdata/b")
+  end
+
+  def test_rm_filelist
+    list = Rake::FileList.new << "testdata/a" << "testdata/b"
+    list.each { |fn| create_file(fn) }
+    FileUtils.rm_r list
+    assert ! File.exist?("testdata/a")
+    assert ! File.exist?("testdata/b")
+  end
+
+  def test_ln
+    create_dir("testdata")
+    open("testdata/a", "w") { |f| f.puts "TEST_LN" }
+    Rake::FileUtilsExt.safe_ln("testdata/a", "testdata/b", :verbose => false)
+    assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
+  end
+
+  class BadLink
+    include Rake::FileUtilsExt
+    attr_reader :cp_args
+    def initialize(klass)
+      @failure_class = klass
+    end
+    def cp(*args)
+      @cp_args = args
+    end
+    def ln(*args)
+      fail @failure_class, "ln not supported"
+    end
+    public :safe_ln
+  end
+
+  def test_safe_ln_failover_to_cp_on_standard_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(StandardError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+    c.safe_ln "x", "y"
+    assert_equal ['x', 'y'], c.cp_args
+  end
+
+  def test_safe_ln_failover_to_cp_on_not_implemented_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(NotImplementedError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+  end
+
+  def test_safe_ln_fails_on_script_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(ScriptError)
+    assert_raises(ScriptError) do c.safe_ln "a", "b" end
+  end
+
+  def test_verbose
+    verbose true
+    assert_equal true, verbose
+    verbose false
+    assert_equal false, verbose
+    verbose(true) {
+      assert_equal true, verbose
+    }
+    assert_equal false, verbose
+  end
+
+  def test_nowrite
+    nowrite true
+    assert_equal true, nowrite
+    nowrite false
+    assert_equal false, nowrite
+    nowrite(true){
+      assert_equal true, nowrite
+    }
+    assert_equal false, nowrite
+  end
+
+  def test_file_utils_methods_are_available_at_top_level
+    create_file("testdata/a")
+    rm_rf "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_fileutils_methods_dont_leak
+    obj = Object.new
+    assert_raises(NoMethodError) { obj.copy } # from FileUtils
+    assert_raises(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils
+  end
+
+  def test_sh
+    verbose(false) { sh %{#{FileUtils::RUBY} test/shellcommand.rb} }
+    assert true, "should not fail"
+  end
+
+  # If the :sh method is invoked directly from a test unit instance
+  # (under mini/test), the mini/test version of fail is invoked rather
+  # than the kernel version of fail. So we run :sh from within a
+  # non-test class to avoid the problem.
+  class Sh
+    include FileUtils
+    def run(*args)
+      sh(*args)
+    end
+    def self.run(*args)
+      new.run(*args)
+    end
+    def self.ruby(*args)
+      Sh.run(RUBY, *args)
+    end
+  end
+
+  def test_sh_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      sh %{#{FileUtils::RUBY} test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_sh_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      Sh.ruby 'test/check_no_expansion.rb', env_var, 'someval'
+    }
+  end
+
+  def test_sh_failure
+    assert_raises(RuntimeError) {
+      verbose(false) { Sh.run %{#{FileUtils::RUBY} test/shellcommand.rb 1} }
+    }
+  end
+
+  def test_sh_special_handling
+    count = 0
+    verbose(false) {
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb}) do |ok, res|
+        assert(ok)
+        assert_equal 0, res.exitstatus
+        count += 1
+      end
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb 1}) do |ok, res|
+        assert(!ok)
+        assert_equal 1, res.exitstatus
+        count += 1
+      end
+    }
+    assert_equal 2, count, "Block count should be 2"
+  end
+
+  def test_sh_noop
+    verbose(false) { sh %{test/shellcommand.rb 1}, :noop=>true }
+    assert true, "should not fail"
+  end
+
+  def test_sh_bad_option
+    ex = assert_raises(ArgumentError) {
+      verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
+    }
+    assert_match(/bad_option/, ex.message)
+  end
+
+  def test_sh_verbose
+    out = redirect_stderr {
+      verbose(true) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_match(/^test\/shellcommand\.rb$/, out)
+  end
+
+  def test_sh_no_verbose
+    out = redirect_stderr {
+      verbose(false) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_equal '', out
+  end
+
+  def test_ruby_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby %{test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_ruby_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby 'test/check_no_expansion.rb', env_var, 'someval'
+    }
+  end
+
+  def test_split_all
+    assert_equal ['a'], Rake::FileUtilsExt.split_all('a')
+    assert_equal ['..'], Rake::FileUtilsExt.split_all('..')
+    assert_equal ['/'], Rake::FileUtilsExt.split_all('/')
+    assert_equal ['a', 'b'], Rake::FileUtilsExt.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Rake::FileUtilsExt.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b')
+  end
+
+  private
+
+  def redirect_stderr
+    old_err = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = old_err
+  end
+
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  end
+
+  def env_var
+    windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
+  end
+
+end

data/dirty_history/ruby/1.9.1/gems/rake-0.9.2/test/test_rake_ftp_file.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../helper', __FILE__)
+require 'date'
+require 'time'
+require 'rake/contrib/ftptools'
+
+class FakeDate
+  def self.today
+    Date.new(2003,10,3)
+  end
+  def self.now
+    Time.local(2003,10,3,12,00,00)
+  end
+end
+
+class TestRakeFtpFile < Rake::TestCase
+
+  def setup
+    super
+
+    Rake::FtpFile.class_eval { @date_class = FakeDate; @time_class = FakeDate }
+  end
+
+  def test_general
+    file = Rake::FtpFile.new("here", "-rw-r--r--   1 a279376  develop   121770 Mar  6 14:50 wiki.pl")
+    assert_equal "wiki.pl", file.name
+    assert_equal "here/wiki.pl", file.path
+    assert_equal "a279376", file.owner
+    assert_equal "develop", file.group
+    assert_equal 0644, file.mode
+    assert_equal 121770, file.size
+    assert_equal Time.mktime(2003,3,6,14,50,0,0), file.time
+    assert ! file.directory?
+    assert ! file.symlink?
+  end
+
+  def test_far_date
+    file = Rake::FtpFile.new(".", "drwxr-xr-x   3 a279376  develop     4096 Nov 26  2001 vss")
+    assert_equal Time.mktime(2001,11,26,0,0,0,0), file.time
+  end
+
+  def test_close_date
+    file = Rake::FtpFile.new(".", "drwxr-xr-x   3 a279376  develop     4096 Nov 26 15:35 vss")
+    assert_equal Time.mktime(2002,11,26,15,35,0,0), file.time
+  end
+
+  def test_directory
+    file = Rake::FtpFile.new(".", "drwxrwxr-x   9 a279376  develop     4096 Mar 13 14:32 working")
+    assert file.directory?
+    assert !file.symlink?
+  end
+
+  def test_symlink
+    file = Rake::FtpFile.new(".", "lrwxrwxrwx   1 a279376  develop       64 Mar 26  2002 xtrac -> /home/a279376/working/ics/development/java/com/fmr/fwp/ics/xtrac")
+    assert_equal 'xtrac', file.name
+    assert file.symlink?
+    assert !file.directory?
+  end
+end
+

data/dirty_history/ruby/1.9.1/gems/rake-0.9.2/test/test_rake_functional.rb

@@ -0,0 +1,468 @@
+begin
+  old_verbose = $VERBOSE
+  $VERBOSE = nil
+  require 'session'
+rescue LoadError
+  if File::ALT_SEPARATOR
+    puts "Unable to run functional tests on MS Windows. Skipping."
+  else
+    puts "Unable to run functional tests -- please run \"gem install session\""
+  end
+ensure
+  $VERBOSE = old_verbose
+end
+
+if defined?(Session)
+  if File::ALT_SEPARATOR
+    puts "Unable to run functional tests on MS Windows. Skipping."
+  end
+end
+
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+
+# Version 2.1.9 of session has a bug where the @debug instance
+# variable is not initialized, causing warning messages.  This snippet
+# of code fixes that problem.
+module Session
+  class AbstractSession
+    alias old_initialize initialize
+    def initialize(*args)
+      @debug = nil
+      old_initialize(*args)
+    end
+  end
+end if defined? Session
+
+class TestRakeFunctional < Rake::TestCase
+
+  RUBY_COMMAND = 'ruby'
+
+  def setup
+    super
+
+    @rake_path = File.expand_path("bin/rake")
+    lib_path = File.expand_path("lib")
+    @ruby_options = ["-I#{lib_path}", "-I."]
+    @verbose = ! ENV['VERBOSE'].nil?
+
+    if @verbose
+      puts
+      puts
+      puts "--------------------------------------------------------------------"
+      puts name
+      puts "--------------------------------------------------------------------"
+    end
+  end
+
+  def test_rake_default
+    Dir.chdir("test/data/default") do rake end
+    assert_match(/^DEFAULT$/, @out)
+    assert_status
+  end
+
+  def test_rake_error_on_bad_task
+    Dir.chdir("test/data/default") do rake "xyz" end
+    assert_match(/rake aborted/, @err)
+    assert_status(1)
+  end
+
+  def test_env_available_at_top_scope
+    Dir.chdir("test/data/default") do rake "TESTTOPSCOPE=1" end
+    assert_match(/^TOPSCOPE$/, @out)
+    assert_status
+  end
+
+  def test_env_available_at_task_scope
+    Dir.chdir("test/data/default") do rake "TESTTASKSCOPE=1 task_scope" end
+    assert_match(/^TASKSCOPE$/, @out)
+    assert_status
+  end
+
+  def test_multi_desc
+    in_environment(
+      'RAKE_COLUMNS' => "80",
+      "PWD" => "test/data/multidesc"
+      ) do
+      rake "-T"
+    end
+    assert_match %r{^rake a *# A / A2 *$}, @out
+    assert_match %r{^rake b *# B *$}, @out
+    refute_match %r{^rake c}, @out
+    assert_match %r{^rake d *# x{65}\.\.\.$}, @out
+  end
+
+  def test_long_description
+    in_environment("PWD" => "test/data/multidesc") do
+      rake "--describe"
+    end
+    assert_match %r{^rake a\n *A / A2 *$}m, @out
+    assert_match %r{^rake b\n *B *$}m, @out
+    assert_match %r{^rake d\n *x{80}}m, @out
+    refute_match %r{^rake c\n}m, @out
+  end
+
+  def test_proper_namespace_access
+    in_environment("PWD" => "test/data/access") do
+      rake
+    end
+    assert_not_match %r{^BAD:}, @out
+  end
+
+  def test_rbext
+    in_environment("PWD" => "test/data/rbext") do
+      rake "-N"
+    end
+    assert_match %r{^OK$}, @out
+  end
+
+  def test_system
+    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
+      rake '-g', "sys1"
+    end
+    assert_match %r{^SYS1}, @out
+  end
+
+  def test_system_excludes_rakelib_files_too
+    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
+      rake '-g', "sys1", '-T', 'extra'
+    end
+    refute_match %r{extra:extra}, @out
+  end
+
+  def test_by_default_rakelib_files_are_included
+    in_environment('RAKE_SYSTEM' => 'test/data/sys', "PWD" => 'test/data/extra') do
+      rake '-T', 'extra', '--trace'
+    end
+    assert_match %r{extra:extra}, @out
+  end
+
+  def test_implicit_system
+    in_environment('RAKE_SYSTEM' => File.expand_path('test/data/sys'), "PWD" => "/") do
+      rake "sys1", "--trace"
+    end
+    assert_match %r{^SYS1}, @out
+  end
+
+  def test_no_system
+    in_environment('RAKE_SYSTEM' => 'test/data/sys', "PWD" => "test/data/extra") do
+      rake '-G', "sys1"
+    end
+    assert_match %r{^Don't know how to build task}, @err # emacs wart: '
+  end
+
+  def test_nosearch_with_rakefile_uses_local_rakefile
+    in_environment("PWD" => "test/data/default") do
+      rake "--nosearch"
+    end
+    assert_match %r{^DEFAULT}, @out
+  end
+
+  def test_nosearch_without_rakefile_finds_system
+    in_environment(
+      "PWD" => "test/data/nosearch",
+      "RAKE_SYSTEM" => File.expand_path("test/data/sys")
+      ) do
+      rake "--nosearch", "sys1"
+    end
+    assert_match %r{^SYS1}, @out
+  end
+
+  def test_nosearch_without_rakefile_and_no_system_fails
+    in_environment("PWD" => "test/data/nosearch", "RAKE_SYSTEM" => "not_exist") do
+      rake "--nosearch"
+    end
+    assert_match %r{^No Rakefile found}, @err
+  end
+
+  def test_invalid_command_line_options
+    in_environment("PWD" => "test/data/default") do
+      rake "--bad-options"
+    end
+    assert_match %r{invalid +option}i, @err
+  end
+
+  def test_inline_verbose_default_should_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "inline_verbose_default"
+    end
+    assert_match(/ruby -e/, @err)
+  end
+
+  def test_inline_verbose_true_should_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "inline_verbose_true"
+    end
+    assert_match(/ruby -e/, @err)
+  end
+
+  def test_inline_verbose_false_should_not_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "inline_verbose_false"
+    end
+    refute_match(/ruby -e/, @err)
+  end
+
+  def test_block_verbose_false_should_not_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "block_verbose_false"
+    end
+    refute_match(/ruby -e/, @err)
+  end
+
+  def test_block_verbose_true_should_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "block_verbose_true"
+    end
+    assert_match(/ruby -e/, @err)
+  end
+
+  def test_standalone_verbose_true_should_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "standalone_verbose_true"
+    end
+    assert_match(/ruby -e/, @err)
+  end
+
+  def test_standalone_verbose_false_should_not_show_command
+    in_environment("PWD" => "test/data/verbose") do
+      rake "standalone_verbose_false"
+    end
+    refute_match(/ruby -e/, @err)
+  end
+
+  def test_dry_run
+    in_environment("PWD" => "test/data/default") do rake "-n", "other" end
+    assert_match %r{Execute \(dry run\) default}, @err
+    assert_match %r{Execute \(dry run\) other}, @err
+    refute_match %r{DEFAULT}, @out
+    refute_match %r{OTHER}, @out
+  end
+
+  # Test for the trace/dry_run bug found by Brian Chandler
+  def test_dry_run_bug
+    in_environment("PWD" => "test/data/dryrun") do
+      rake
+    end
+    FileUtils.rm_f "test/data/dryrun/temp_one"
+    in_environment("PWD" => "test/data/dryrun") do
+      rake "--dry-run"
+    end
+    refute_match(/No such file/, @out)
+    assert_status
+  end
+
+  # Test for the trace/dry_run bug found by Brian Chandler
+  def test_trace_bug
+    in_environment("PWD" => "test/data/dryrun") do
+      rake
+    end
+    FileUtils.rm_f "test/data/dryrun/temp_one"
+    in_environment("PWD" => "test/data/dryrun") do
+      rake "--trace"
+    end
+    refute_match(/No such file/, @out)
+    assert_status
+  end
+
+  def test_imports
+    open("test/data/imports/static_deps", "w") do |f|
+      f.puts 'puts "STATIC"'
+    end
+    FileUtils.rm_f "test/data/imports/dynamic_deps"
+    in_environment("PWD" => "test/data/imports") do
+      rake
+    end
+    assert File.exist?("test/data/imports/dynamic_deps"),
+      "'dynamic_deps' file should exist"
+    assert_match(/^FIRST$\s+^DYNAMIC$\s+^STATIC$\s+^OTHER$/, @out)
+    assert_status
+    FileUtils.rm_f "test/data/imports/dynamic_deps"
+    FileUtils.rm_f "test/data/imports/static_deps"
+  end
+
+  def test_rules_chaining_to_file_task
+    remove_chaining_files
+    in_environment("PWD" => "test/data/chains") do
+      rake
+    end
+    assert File.exist?("test/data/chains/play.app"),
+      "'play.app' file should exist"
+    assert_status
+    remove_chaining_files
+  end
+
+  def test_file_creation_task
+    in_environment("PWD" => "test/data/file_creation_task") do
+      rake "prep"
+      rake "run"
+      rake "run"
+    end
+    assert(@err !~ /^cp src/, "Should not recopy data")
+  end
+
+  def test_dash_f_with_no_arg_foils_rakefile_lookup
+    rake "-I test/data/rakelib -rtest1 -f"
+    assert_match(/^TEST1$/, @out)
+  end
+
+  def test_dot_rake_files_can_be_loaded_with_dash_r
+    rake "-I test/data/rakelib -rtest2 -f"
+    assert_match(/^TEST2$/, @out)
+  end
+
+  def test_can_invoke_task_in_toplevel_namespace
+    in_environment("PWD" => "test/data/namespace") do
+      rake "copy"
+    end
+    assert_match(/^COPY$/, @out)
+  end
+
+  def test_can_invoke_task_in_nested_namespace
+    in_environment("PWD" => "test/data/namespace") do
+      rake "nest:copy"
+      assert_match(/^NEST COPY$/, @out)
+    end
+  end
+
+  def test_tasks_can_reference_task_in_same_namespace
+    in_environment("PWD" => "test/data/namespace") do
+      rake "nest:xx"
+      assert_match(/^NEST COPY$/m, @out)
+    end
+  end
+
+  def test_tasks_can_reference_task_in_other_namespaces
+    in_environment("PWD" => "test/data/namespace") do
+      rake "b:run"
+      assert_match(/^IN A\nIN B$/m, @out)
+    end
+  end
+
+  def test_anonymous_tasks_can_be_invoked_indirectly
+    in_environment("PWD" => "test/data/namespace") do
+      rake "anon"
+      assert_match(/^ANON COPY$/m, @out)
+    end
+  end
+
+  def test_rake_namespace_refers_to_toplevel
+    in_environment("PWD" => "test/data/namespace") do
+      rake "very:nested:run"
+      assert_match(/^COPY$/m, @out)
+    end
+  end
+
+  def test_file_task_are_not_scoped_by_namespaces
+    in_environment("PWD" => "test/data/namespace") do
+      rake "xyz.rb"
+      assert_match(/^XYZ1\nXYZ2$/m, @out)
+    end
+  end
+
+  def test_file_task_dependencies_scoped_by_namespaces
+    in_environment("PWD" => "test/data/namespace") do
+      rake "scopedep.rb"
+      assert_match(/^PREPARE\nSCOPEDEP$/m, @out)
+    end
+  ensure
+    remove_namespace_files
+  end
+
+  def test_rake_returns_status_error_values
+    in_environment("PWD" => "test/data/statusreturn") do
+      rake "exit5"
+      assert_status(5)
+    end
+  end
+
+  def test_rake_returns_no_status_error_on_normal_exit
+    in_environment("PWD" => "test/data/statusreturn") do
+      rake "normal"
+      assert_status(0)
+    end
+  end
+
+  def test_comment_before_task_acts_like_desc
+    in_environment("PWD" => "test/data/comments") do
+      rake "-T"
+    end
+    refute_match(/comment for t1/, @out)
+  end
+
+  def test_comment_separated_from_task_by_blank_line_is_not_picked_up
+    Dir.chdir("test/data/comments") { rake("-T")}
+    assert_not_match("t2", @out)
+  end
+
+  def test_comment_after_desc_is_ignored
+    Dir.chdir("test/data/comments") { rake("-T")}
+    assert_match("override comment for t3", @out)
+  end
+
+  def test_comment_before_desc_is_ignored
+    Dir.chdir("test/data/comments") { rake("-T")}
+    assert_match("override comment for t4", @out)
+  end
+
+  def test_correct_number_of_tasks_reported
+    Dir.chdir("test/data/comments") { rake("-T")}
+    assert_equal(2, @out.split(/\n/).grep(/t\d/).size)
+  end
+
+  def test_file_list_is_requirable_separately
+    ruby "-rrake/file_list", "-e 'puts Rake::FileList[\"a\"].size'"
+    assert_equal "1\n", @out
+    assert_equal 0, @status
+  end
+
+  private
+
+  def assert_not_match(pattern, string, comment="'#{pattern}' was found (incorrectly) in '#{string}.inspect")
+    assert_nil Regexp.new(pattern).match(string), comment
+  end
+
+  def remove_chaining_files
+    %w(play.scpt play.app base).each do |fn|
+      FileUtils.rm_f File.join("test/data/chains", fn)
+    end
+  end
+
+  def remove_namespace_files
+    %w(scopedep.rb).each do |fn|
+      FileUtils.rm_f File.join("test/data/namespace", fn)
+    end
+  end
+
+  # Run a shell Ruby command with command line options (using the
+  # default test options). Output is captured in @out, @err and
+  # @status.
+  def ruby(*option_list)
+    run_ruby(@ruby_options + option_list)
+  end
+
+  # Run a command line rake with the give rake options.  Default
+  # command line ruby options are included.  Output is captured in
+  # @out, @err and @status.
+  def rake(*rake_options)
+    run_ruby @ruby_options + [@rake_path] + rake_options
+  end
+
+  # Low level ruby command runner ...
+  def run_ruby(option_list)
+    shell = Session::Shell.new
+    command = "#{RUBY_COMMAND} " + option_list.join(' ')
+    puts "COMMAND: [#{command}]" if @verbose
+    @out, @err = shell.execute command
+    @status = shell.exit_status
+    puts "STATUS:  [#{@status}]" if @verbose
+    puts "OUTPUT:  [#{@out}]" if @verbose
+    puts "ERROR:   [#{@err}]" if @verbose
+    puts "PWD:     [#{Dir.pwd}]" if @verbose
+    shell.close
+  end
+
+  def assert_status(expected_status=0)
+    assert_equal expected_status, @status
+  end
+end if defined?(Session)