rake 0.9.2 → 13.0.3

data/test/test_rake_file_list_path_map.rb

@@ -1,8 +0,0 @@
-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/test/test_rake_file_task.rb

@@ -1,104 +0,0 @@
-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/test/test_rake_file_utils.rb

@@ -1,252 +0,0 @@
-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/test/test_rake_ftp_file.rb

@@ -1,59 +0,0 @@
-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/test/test_rake_functional.rb

@@ -1,468 +0,0 @@
-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)