rake 0.4.11 → 13.4.2

data/test/testfilelist.rb

@@ -1,255 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake'
-
-class TestFileList < Test::Unit::TestCase
-  FileList = Rake::FileList
-
-  def setup
-    create_test_data
-  end
-
-  def teardown
-    FileList.select_default_ignore_patterns
-  end
-
-  def test_create
-    fl = FileList.new
-    assert_equal 0, fl.size
-  end
-
-  def test_create_with_args
-    fl = FileList.new("testdata/*.c", "x")
-    assert_equal ["testdata/abc.c", "testdata/x.c", "testdata/xyz.c", "x"].sort,
-      fl.sort
-  end
-
-  def test_create_with_block
-    fl = FileList.new { |f| f.include("x") }
-    assert_equal ["x"], fl.resolve
-  end
-
-  def test_create_with_brackets
-    fl = FileList["testdata/*.c", "x"]
-    assert_equal ["testdata/abc.c", "testdata/x.c", "testdata/xyz.c", "x"].sort,
-      fl.sort
-  end
-
-  def test_append
-    fl = FileList.new
-    fl << "a.rb" << "b.rb"
-    assert_equal ['a.rb', 'b.rb'], fl
-  end
-
-  def test_add_many
-    fl = FileList.new
-    fl.include %w(a d c )
-    fl.include('x', 'y')
-    assert_equal ['a', 'd', 'c', 'x', 'y'], fl.resolve
-  end
-
-  def test_add_return
-    f = FileList.new
-    g = f << "x"
-    assert_equal f.id, g.id
-    h = f.include("y")
-    assert_equal f.id, h.id
-  end
-  
-  def test_match
-    fl = FileList.new
-    fl.include('test/test*.rb')
-    assert fl.include?("test/testfilelist.rb")
-    assert fl.size > 3
-    fl.each { |fn| assert_match /\.rb$/, fn }
-  end
-
-  def test_add_matching
-    fl = FileList.new
-    fl << "a.java"
-    fl.include("test/*.rb")
-    assert_equal "a.java", fl[0]
-    assert fl.size > 2
-    assert fl.include?("test/testfilelist.rb")
-  end
-
-  def test_multiple_patterns
-    create_test_data
-    fl = FileList.new
-    fl.include('*.c', '*xist*')
-    assert_equal [], fl
-    fl.include('testdata/*.c', 'testdata/*xist*')
-    assert_equal [
-      'testdata/x.c', 'testdata/xyz.c', 'testdata/abc.c', 'testdata/existing'
-    ].sort, fl.sort
-  end
-
-  def test_reject
-    fl = FileList.new
-    fl.include %w(testdata/x.c testdata/abc.c testdata/xyz.c testdata/existing)
-    fl.reject! { |fn| fn =~ %r{/x} }
-    assert_equal [
-      'testdata/abc.c', 'testdata/existing'
-    ], fl
-  end
-
-  def test_exclude
-    fl = FileList['testdata/x.c', 'testdata/abc.c', 'testdata/xyz.c', 'testdata/existing']
-    fl.each { |fn| touch fn, :verbose => false }
-    x = fl.exclude(%r{/x.+\.})
-    assert_equal FileList, x.class
-    assert_equal [
-      'testdata/x.c', 'testdata/abc.c', 'testdata/existing'
-    ], fl
-    assert_equal fl.id, x.id
-    fl.exclude('testdata/*.c')
-    assert_equal ['testdata/existing'], fl
-    fl.exclude('testdata/existing')
-    assert_equal [], fl
-  end
-
-  def test_exclude_return_on_create
-    fl = FileList['testdata/*'].exclude(/.*\.c$/)
-    assert_equal FileList, fl.class
-  end
-
-  def test_default_exclude
-    fl = FileList.new
-    fl.clear_exclude
-    fl.include("**/*~", "**/*.bak", "**/core")
-    assert fl.member?("testdata/core"), "Should include core"
-    assert fl.member?("testdata/x.bak"), "Should include .bak files"
-  end
-
-  def test_unique
-    fl = FileList.new
-    fl << "x.c" << "a.c" << "b.rb" << "a.c"
-    assert_equal ['x.c', 'a.c', 'b.rb', 'a.c'], fl
-    fl.uniq!
-    assert_equal ['x.c', 'a.c', 'b.rb'], fl
-  end
-
-  def test_to_string
-    fl = FileList.new
-    fl << "a.java" << "b.java"
-    assert_equal  "a.java b.java", fl.to_s
-    assert_equal  "a.java b.java", "#{fl}"
-  end
-
-  def test_to_s_pending
-    fl = FileList['testdata/abc.*']
-    assert_equal  %{testdata/abc.c}, fl.to_s
-  end
-
-  def test_inspect_pending
-    fl = FileList['testdata/abc.*']
-    assert_equal  %{["testdata/abc.c"]}, fl.inspect
-  end
-
-  def test_sub
-    fl = FileList["testdata/*.c"]
-    f2 = fl.sub(/\.c$/, ".o")
-    assert_equal FileList, f2.class
-    assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
-      f2.sort
-    f3 = fl.gsub(/\.c$/, ".o")
-    assert_equal FileList, f3.class
-    assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
-      f3.sort
-  end
-
-  def test_sub!
-    f = "x/a.c"
-    fl = FileList[f, "x/b.c"]
-    res = fl.sub!(/\.c$/, ".o")
-    assert_equal ["x/a.o", "x/b.o"].sort, fl.sort
-    assert_equal "x/a.c", f
-    assert_equal fl.id, res.id
-  end
-
-  def test_sub_with_block
-    fl = FileList["src/org/onestepback/a.java", "src/org/onestepback/b.java"]
-# The block version doesn't work the way I want it to ...
-#    f2 = fl.sub(%r{^src/(.*)\.java$}) { |x|  "classes/" + $1 + ".class" }
-    f2 = fl.sub(%r{^src/(.*)\.java$}, "classes/\\1.class")
-    assert_equal [
-      "classes/org/onestepback/a.class",
-      "classes/org/onestepback/b.class"
-    ].sort,
-      f2.sort
-  end
-
-  def test_gsub
-    create_test_data
-    fl = FileList["testdata/*.c"]
-    f2 = fl.gsub(/a/, "A")
-    assert_equal ["testdAtA/Abc.c", "testdAtA/x.c", "testdAtA/xyz.c"].sort,
-      f2.sort
-  end
-
-  def test_ignore_special
-    f = FileList['testdata/*']
-    assert ! f.include?("testdata/CVS"), "Should not contain CVS"
-    assert ! f.include?("testdata/.dummy"), "Should not contain dot files"
-    assert ! f.include?("testdata/x.bak"), "Should not contain .bak files"
-    assert ! f.include?("testdata/x~"), "Should not contain ~ files"
-    assert ! f.include?("testdata/core"), "Should not contain core files"
-  end
-
-  def test_clear_ignore_patterns
-    f = FileList['testdata/*']
-    f.clear_exclude
-    assert f.include?("testdata/abc.c")
-    assert f.include?("testdata/xyz.c")
-    assert f.include?("testdata/CVS")
-    assert f.include?("testdata/x.bak")
-    assert f.include?("testdata/x~")
-  end
-
-  def test_exclude_with_alternate_file_seps
-    fl = FileList.new
-    assert fl.exclude?("x/CVS/y")
-    assert fl.exclude?("x\\CVS\\y")
-    assert fl.exclude?("x/core")
-    assert fl.exclude?("x\\core")
-  end
-
-  def test_add_default_exclude_list
-    fl = FileList.new
-    fl.exclude(/~\d+$/)
-    assert fl.exclude?("x/CVS/y")
-    assert fl.exclude?("x\\CVS\\y")
-    assert fl.exclude?("x/core")
-    assert fl.exclude?("x\\core")
-    assert fl.exclude?("x/abc~1")
-  end
-
-  def test_basic_array_functions
-    f = FileList['b', 'c', 'a']
-    assert_equal 'b', f.first
-    assert_equal 'b', f[0]
-    assert_equal 'a', f.last
-    assert_equal 'a', f[2]
-    assert_equal 'a', f[-1]
-    assert_equal ['a', 'b', 'c'], f.sort
-    f.sort!
-    assert_equal ['a', 'b', 'c'], f
-  end
-
-  def create_test_data
-    verbose(false) do
-      mkdir "testdata" unless File.exist? "testdata"
-      mkdir "testdata/CVS" rescue nil
-      touch "testdata/.dummy"
-      touch "testdata/x.bak"
-      touch "testdata/x~"
-      touch "testdata/core"
-      touch "testdata/x.c"
-      touch "testdata/xyz.c"
-      touch "testdata/abc.c"
-      touch "testdata/existing"
-    end
-  end
-  
-end

data/test/testfileutils.rb

@@ -1,83 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rake'
-require 'test/unit'
-require 'test/filecreation'
-require 'fileutils'
-
-class TestFileUtils < Test::Unit::TestCase
-  include FileCreation
-
-  def test_rm_one_file
-    create_file("testdata/a")
-    FileUtils.rm_r "testdata/a"
-    assert ! File.exist?("testdata/a")
-  end
-
-  def test_rm_two_files
-    create_file("testdata/a")
-    create_file("testdata/b")
-    FileUtils.rm_r ["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_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_sh
-    verbose(false) { sh %{test/shellcommand.rb} }
-    assert true, "should not fail"
-  end
-
-  def test_sh_failure
-    assert_raises(RuntimeError) { 
-      verbose(false) { sh %{test/shellcommand.rb 1} }
-    }
-  end
-
-  def test_sh_special_handling
-    count = 0
-    verbose(false) {
-      sh(%{test/shellcommand.rb}) do |ok, res|
-	assert(ok)
-	assert_equal 0, res.exitstatus
-	count += 1
-      end
-      sh(%{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
-
-end

data/test/testftp.rb

@@ -1,55 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'date'
-require 'test/unit'
-require 'rake/contrib/ftptools'
-
-class FakeDate
-  def self.today
-    Date.new(2003,10,3)
-  end
-end
-
-
-class TestFtpFile < Test::Unit::TestCase
-
-  def setup
-    Rake::FtpFile.class_eval { @date_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/testpackagetask.rb

@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake/packagetask'
-
-class TestPackageTask < Test::Unit::TestCase
-  def test_create
-    pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
-      p.package_files << "install.rb"
-      p.package_files.include(
-	'[A-Z]*',
-	'bin/**/*',
-	'lib/**/*.rb',
-	'test/**/*.rb',
-	'doc/**/*',
-	'build/rubyapp.rb',
-	'*.blurb')
-      p.package_files.exclude(/\bCVS\b/)
-      p.package_files.exclude(/~$/)
-      p.package_dir = 'pkg'
-      p.need_tar = true
-      p.need_zip = true
-    }
-    assert_equal "pkg", pkg.package_dir
-    assert pkg.package_files.include?("bin/rake")
-    assert "pkgr", pkg.name
-    assert "1.2.3", pkg.version
-    assert Task[:package]
-    assert Task['pkg/pkgr-1.2.3.tgz']
-    assert Task['pkg/pkgr-1.2.3.zip']
-    assert Task["pkg/pkgr-1.2.3"]
-    assert Task[:clobber_package]
-    assert Task[:repackage]
-  end
-
-  def test_missing_version
-    assert_raises(RuntimeError) {
-      pkg = Rake::PackageTask.new("pkgr") { |p| }
-    }
-  end
-
-  def test_no_version
-    pkg = Rake::PackageTask.new("pkgr", :noversion) { |p| }
-    assert "pkgr", pkg.send(:package_name)
-  end
-
-  def test_clone
-    pkg = Rake::PackageTask.new("x", :noversion)
-    p2 = pkg.clone
-    pkg.package_files << "y"
-    p2.package_files << "x"
-    assert_equal ["y"], pkg.package_files
-    assert_equal ["x"], p2.package_files
-  end
-end
-
-
-begin
-  require 'rubygems'
-  require 'rake/gempackagetask'
-rescue Exception
-  puts "WARNING: RubyGems not installed"
-end
-
-if ! defined?(Gem)
-  puts "WARNING: Unable to test GemPackaging ... requires RubyGems"
-else
-  class TestGemPackageTask < Test::Unit::TestCase
-    def test_gem_package
-      gem = Gem::Specification.new do |g|
-	g.name = "pkgr"
-	g.version = "1.2.3"
-	g.files = FileList["x"].resolve
-      end
-      pkg = Rake::GemPackageTask.new(gem)  do |p|
-	p.package_files << "y"
-      end
-      assert_equal ["x", "y"], pkg.package_files
-    end
-  end
-end