rant 0.4.2 → 0.4.4

data/test/import/nodes/signed/test_signed.rb

@@ -0,0 +1,455 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportNodesSignedDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestNodesSigned < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testImportNodesSignedDir)
+    end
+    def teardown
+	Dir.chdir($testImportNodesSignedDir)
+        assert_rant("autoclean")
+        assert(Dir["*.t"].empty?)
+        assert(Dir["*.tt"].empty?)
+        assert(Dir["sub1/*.t"].empty?)
+        assert(Dir["sub1/*.tt"].empty?)
+        assert(!test(?e, ".rant.meta"))
+    end
+    def write(fn, str)
+        open fn, "w" do |f|
+            f.write str
+        end
+    end
+    def test_file
+        out, err = assert_rant("f1.t")
+        assert(err.empty?)
+        assert_equal("writing f1.t\n", out)
+        assert(test(?f, "f1.t"))
+        assert_equal("1\n", File.read("f1.t"))
+        out, err = assert_rant
+        assert(out.empty?)
+        assert(err.empty?)
+        assert(!test(?e, "a"))
+        write("f1.t", "2\n")
+        out, err = assert_rant
+        assert_equal("writing f1.t\n", out)
+        assert(test(?f, "f1.t"))
+        assert_equal("1\n", File.read("f1.t"))
+        out, err = assert_rant
+        assert(out.empty?)
+        assert(err.empty?)
+    end
+    def test_directory
+        out, err = assert_rant("d1.t")
+        assert(test(?d, "d1.t"))
+        out, err = assert_rant("d1.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_directory_with_pre_and_block
+        write("a.t", "a\n")
+        out, err = assert_rant(:fail, "base.t/s/s")
+        assert(!test(?e, "base.t"))
+        assert_match(/Rantfile[^\n]+14/, err)
+        assert_match(/base\.t/, err)
+        FileUtils.mkdir "base.t"
+        out, err = assert_rant("base.t/s/s")
+        assert(test(?f, "base.t/s/s/t"))
+        assert_equal("a\n1\n", File.read("base.t/s/s/t"))
+        out, err = assert_rant("base.t/s/s")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("-af1.t", "content=2")
+        assert_equal("2", File.read("f1.t"))
+        out, err = assert_rant("base.t/s/s")
+        assert(test(?f, "base.t/s/s/t"))
+        assert_equal("a\n2", File.read("base.t/s/s/t"))
+        assert(!out.include?("f1.t"))
+        assert(out.include?("copying"))
+        out, err = assert_rant("base.t/s/s")
+        assert(out.empty?)
+        assert(err.empty?)
+    ensure
+        FileUtils.rm_f "a.t"
+        FileUtils.rm_rf "base.t"
+    end
+    def test_subfile
+        out, err = assert_rant("d2.t/f", "subfile=1")
+        assert(err.empty?)
+        assert(test(?f, "f1.t"))
+        assert(test(?f, "d2.t/f"))
+        assert_equal("1\n", File.read("f1.t"))
+        assert_equal("1\n", File.read("d2.t/f"))
+        out, err = assert_rant("d2.t/f", "subfile=1")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("subfile=1", "autoclean")
+    end
+    def test_file_with_dep_on_dir_with_pre_and_block
+        FileUtils.mkdir "base.t"
+        write("a.t", "a\n")
+        out, err = assert_rant("f2.t")
+        assert(test(?f, "base.t/s/s/t"))
+        assert(test(?f, "f2.t"))
+        assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
+        assert(err.empty?)
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        FileUtils.rm "f2.t"
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert_equal("cp base.t/s/s/t f2.t\n", out)
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("a.t", "aa\n")
+        out, err = assert_rant("f2.t")
+        assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
+        assert(err.empty?)
+        assert_match(/\bcp\b/, out)
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f "a.t"
+        FileUtils.rm_rf "base.t"
+    end
+    def test_source_node_single_fail
+        out, err = assert_rant(:fail, "f3.t")
+        assert(out.empty?)
+        assert(!test(?e, "f3.t"))
+        assert(!test(?e, "c1.t"))
+        assert(!test(?e, ".rant.meta"))
+        lines = err.split(/\n/)
+        assert(lines.size < 5)
+        assert_match(/ERROR.*Rantfile.*34/, lines[0])
+        assert_match(/SourceNode.*c1\.t/, lines[1])
+        assert_match(/Task.*f3\.t.*fail/, lines[2])
+    end
+    def test_source_node_single
+        write("c1.t", "c\n")
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(test(?f, "f3.t"))
+        assert_equal("c\n", File.read("f3.t"))
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(!test(?e, "f3.t"))
+        assert(test(?f, "c1.t"))
+        assert_equal("c\n", File.read("c1.t"))
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(test(?f, "f3.t"))
+        assert_equal("c\n", File.read("f3.t"))
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("c1.t", "c1\n")
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert_equal("writing f3.t\n", out)
+        assert_equal("c1\n", File.read("f3.t"))
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f "c1.t"
+    end
+    def test_source_node_fail
+        write("c1.t", "c\n")
+        write("c2.t", "c\n")
+        out, err = assert_rant(:fail, "f4.t")
+        assert(test(?f, "f3.t"))
+        assert_equal("writing f3.t\n", out)
+        lines = err.split(/\n/)
+        assert(lines.size < 5)
+        assert_match(/ERROR.*Rantfile.*36/, lines[0])
+        assert_match(/SourceNode.*c3\.t/, lines[1])
+        assert_match(/Task.*f4\.t.*fail/, lines[2])
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f "c1.t"
+        FileUtils.rm_f "c2.t"
+    end
+    def test_source_node
+        write("c1.t", "c\n")
+        write("c2.t", "c\n")
+        write("c3.t", "c\n")
+        out, err = assert_rant("f4.t")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?f, "f3.t"))
+        assert(test(?f, "f4.t"))
+        assert_equal("c\nc\n", File.read("f4.t"))
+        out, err = assert_rant("f4.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("c3.t", "c3\n")
+        out, err = assert_rant("f4.t")
+        assert(err.empty?)
+        assert_equal("writing f4.t\n", out)
+        assert_equal("c\nc\n", File.read("f4.t"))
+        out, err = assert_rant("f4.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(test(?f, "c1.t"))
+        assert(test(?f, "c2.t"))
+        assert(test(?f, "c3.t"))
+        assert(!test(?e, "f3.t"))
+        assert(!test(?e, "f4.t"))
+    ensure
+        FileUtils.rm_f "c1.t"
+        FileUtils.rm_f "c2.t"
+        FileUtils.rm_f "c3.t"
+    end
+    def test_2source_node
+        write("c1.t", "c\n")
+        write("c2.t", "c\n")
+        write("c3.t", "c\n")
+        write("c4.t", "c\n")
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(test(?f, "f5.t"))
+        assert_match(/cp.*c2\.t.*f5\.t/, out)
+        assert_equal("c\n", File.read("f5.t"))
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("c3.t", "c3\n")
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert_match(/cp.*c2\.t.*f5\.t/, out)
+        assert_equal("c\n", File.read("f5.t"))
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(test(?f, "c1.t"))
+        assert(test(?f, "c2.t"))
+        assert(test(?f, "c3.t"))
+        assert(test(?f, "c4.t"))
+        assert(!test(?e, "f5.t"))
+    ensure
+        FileUtils.rm_f "c1.t"
+        FileUtils.rm_f "c2.t"
+        FileUtils.rm_f "c3.t"
+        FileUtils.rm_f "c4.t"
+    end
+    def test_source_node_in_subdir
+        write("sub1/c1.t", "c\n")
+        write("sub1/c2.t", "c\n")
+        write("c5.t", "c\n")
+        write("c6.t", "c\n")
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        assert_equal("writing f6.t\n", out)
+        assert(test(?f, "f6.t"))
+        assert_equal("1\n", File.read("f6.t"))
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("sub1/c2.t", "c2\n")
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        assert_equal("writing f6.t\n", out)
+        assert_equal("1\n", File.read("f6.t"))
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(test(?f, "sub1/c1.t"))
+        assert(test(?f, "sub1/c2.t"))
+        assert(test(?f, "c5.t"))
+        assert(test(?f, "c6.t"))
+        assert(!test(?e, "f6.t"))
+    ensure
+        FileUtils.rm_f "sub1/c1.t"
+        FileUtils.rm_f "sub1/c2.t"
+        FileUtils.rm_f "c5.t"
+        FileUtils.rm_f "c6.t"
+    end
+    def test_rule
+        write("sub1/c1.t", "c\n")
+        write("sub1/c2.t", "c\n")
+        write("c5.t", "c\n")
+        write("c6.t", "c\n")
+        out, err = assert_rant("c5.r.t")
+        assert(err.empty?)
+        assert_match(/cp.*c5\.t.*c5\.r\.t\n/, out)
+        assert(test(?f, "c5.r.t"))
+        assert_equal("c\n", File.read("c5.r.t"))
+        out, err = assert_rant("c5.r.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("sub1/c2.t", "c2\n")
+        out, err = assert_rant("c5.r.t")
+        assert(err.empty?)
+        assert_match(/cp.*c5\.t.*c5\.r\.t\n/, out)
+        assert_equal("c\n", File.read("c5.r.t"))
+        out, err = assert_rant("c5.r.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(test(?f, "sub1/c1.t"))
+        assert(test(?f, "sub1/c2.t"))
+        assert(test(?f, "c5.t"))
+        assert(test(?f, "c6.t"))
+        assert(!test(?e, "c5.r.t"))
+    ensure
+        FileUtils.rm_f "sub1/c1.t"
+        FileUtils.rm_f "sub1/c2.t"
+        FileUtils.rm_f "c5.t"
+        FileUtils.rm_f "c6.t"
+    end
+    def test_2rule
+        write("1.tt", "t\n")
+        out, err = assert_rant("1.r.t")
+        assert(err.empty?)
+        assert_match(/cp.*1\.tt.*1\.r\.t/, out)
+        assert(test(?f, "1.r.t"))
+        assert_equal("t\n", File.read("1.r.t"))
+        out, err = assert_rant("1.r.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("1.tt", "r\n")
+        out, err = assert_rant("1.r.t")
+        assert(err.empty?)
+        assert_match(/cp.*1\.tt.*1\.r\.t/, out)
+        assert(test(?f, "1.r.t"))
+        assert_equal("r\n", File.read("1.r.t"))
+        out, err = assert_rant("1.r.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f "1.tt"
+    end
+    def test_source_node_with_file_pre
+        write("c7.t", "c\n")
+        write("c8.t", "c\n")
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert_match(/cp.*c7\.t.*f7\.t/, out)
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("c8.t", "c8\n")
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert_match(/cp.*c7\.t.*f7\.t/, out)
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("-af1.t", "content=2")
+        assert_equal("2", File.read("f1.t"))
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert_match(/cp.*c7\.t.*f7\.t/, out)
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(test(?f, "c7.t"))
+        assert(test(?f, "c8.t"))
+        assert(!test(?e, "f7.t"))
+    ensure
+        FileUtils.rm_f "c7.t"
+        FileUtils.rm_f "c8.t"
+    end
+    def test_source_node_no_invoke_pre
+        write("c7.t", "c\n")
+        write("c8.t", "c\n")
+        out, err = assert_rant("c7.t")
+        assert(err.empty?)
+        assert(!test(?e, "f1.t"),
+            "SourceNode#invoke shouldn't invoke prerequisites")
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f "c7.t"
+        FileUtils.rm_f "c8.t"
+    end
+    def test_file_last_pre_in_subdir
+        out, err = assert_rant("f8.t", "content=8")
+        assert(err.empty?)
+        assert(test(?f, "sub1/f1.t"))
+        assert(test(?f, "f8.t"))
+        assert(!test(?e, "f1.t"))
+        assert_equal("8", File.read("sub1/f1.t"))
+        assert_equal("8", File.read("f8.t"))
+        out, err = assert_rant("f8.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_rant_import_auto
+        out = run_import("-q", "--auto", "make.t")
+        assert_exit
+        FileUtils.mkdir "base.t"
+        write("a.t", "a\n")
+        out = run_ruby("make.t", "--tasks")
+        assert_exit
+        lines = out.split(/\n/)
+        assert_equal(2, lines.size)
+        assert_match(/f1\.t/, lines.first)
+        assert_match(/f8\.t.*copy f1\.t from sub1 to f8\.t/, lines[1])
+        out = run_ruby("make.t", "f2.t")
+        assert_exit
+        assert(test(?f, "base.t/s/s/t"))
+        assert(test(?f, "f2.t"))
+        assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
+        out = run_ruby("make.t", "f2.t")
+        assert_exit
+        assert(out.empty?)
+        run_ruby("make.t", "autoclean")
+        assert_exit
+        assert(test(?f, "a.t"))
+        assert(!test(?e, "base.t/s"))
+        assert(!test(?e, "f2.t"))
+    ensure
+        FileUtils.rm_rf "base.t"
+        FileUtils.rm_f "a.t"
+        FileUtils.rm_f "make.t"
+    end
+    def test_rant_import
+        run_import("-q", "-imd5,autoclean", "make.t")
+        assert_exit
+        write("sub1/c1.t", "c\n")
+        write("sub1/c2.t", "c\n")
+        write("c5.t", "c\n")
+        write("c6.t", "c\n")
+        out = run_ruby("make.t", "f6.t")
+        assert_equal("writing f6.t", out.strip)
+        assert(test(?f, "f6.t"))
+        assert_equal("1\n", File.read("f6.t"))
+        out = run_ruby("make.t", "f6.t")
+        assert(out.strip.empty?)
+        write("sub1/c2.t", "c2\n")
+        out = run_ruby("make.t", "f6.t")
+        assert_equal("writing f6.t", out.strip)
+        assert_equal("1\n", File.read("f6.t"))
+        out = run_ruby("make.t", "f6.t")
+        assert(out.empty?)
+        run_ruby("make.t", "autoclean")
+        assert(test(?f, "sub1/c1.t"))
+        assert(test(?f, "sub1/c2.t"))
+        assert(test(?f, "c5.t"))
+        assert(test(?f, "c6.t"))
+        assert(!test(?e, "f6.t"))
+    ensure
+        FileUtils.rm_f "make.t"
+        FileUtils.rm_f "sub1/c1.t"
+        FileUtils.rm_f "sub1/c2.t"
+        FileUtils.rm_f "c5.t"
+        FileUtils.rm_f "c6.t"
+    end
+end

data/test/import/package/md5.rf

@@ -0,0 +1,10 @@
+
+import %w(md5 package/zip package/tgz autoclean)
+
+gen Package::Zip, "pkg.t/m1", :files => sys["sub*/*"].shun("pkg.t")
+
+gen Package::Tgz, "pkg.t/m1", :files => sys["sub*/*"].shun("pkg.t")
+
+gen AutoClean, "clean"
+
+# vim:ft=ruby

data/test/import/package/test_package.rb

@@ -91,6 +91,32 @@ class TestImportPackage < Test::Unit::TestCase
     ensure
 	FileUtils.rm_rf "sub/f5"
     end
+    def test_tgz_sync_manifest_md5
+	assert_rant("-imd5", "t2.tgz")
+	mf = %w(sub/f1 sub2/f1 m2.tgz.t)
+	dirs = %w(sub sub2)
+	check_manifest("m2.tgz.t", mf)
+	check_contents(:tgz, "t2.tgz", mf, dirs, "m2.tgz.t")
+	out, err = assert_rant("t2.tgz")
+	assert(out.strip.empty?)
+	assert(err.strip.empty?)
+	FileUtils.touch "sub/f5"
+	out, err = assert_rant("-imd5", "t2.tgz")
+	assert_match(/writing m2\.tgz\.t.*\n.*tar/m, out)
+	check_contents(:tgz, "t2.tgz", mf + %w(sub/f5), dirs, "m2.tgz.t")
+	FileUtils.rm "sub/f5"
+	out, err = assert_rant("-imd5", "t2.tgz")
+	assert_match(/writing m2\.tgz\.t.*\n.*tar/m, out)
+	check_contents(:tgz, "t2.tgz", mf, dirs, "m2.tgz.t")
+	# test autoclean
+	assert_rant("-imd5", "autoclean")
+	assert(!test(?e, "m2.tgz.t"))
+	# hmm.. the tgz will be removed by check_contents anyway...
+	assert(!test(?e, "t2.tgz"))
+        assert(!test(?e, ".rant.meta"))
+    ensure
+	FileUtils.rm_rf "sub/f5"
+    end
     def test_tgz_files_array
 	assert_rant("t3.tgz")
 	mf = %w(Rantfile sub/f1)
@@ -141,7 +167,7 @@ class TestImportPackage < Test::Unit::TestCase
 	out, err = assert_rant("sub.t/pkg.tgz")
 	assert(!out.empty?)
 	out, err = assert_rant("sub.t/pkg.tgz")
-	assert(out.empty?)
+	assert(out.strip.empty?)
 	assert(test(?d, "sub.t/pkg"))
 	@pkg_dir = "pkg"
 	mf = %w(sub/f1)
@@ -411,6 +437,24 @@ class TestImportPackage < Test::Unit::TestCase
     ensure
 	FileUtils.rm_rf "zip.t"
     end
+    def test_zip_with_basedir_md5
+	assert_rant(:fail, "-imd5", "zip.t/t4-1.0.0.zip")
+	assert(!test(?d, "zip.t"))
+	FileUtils.mkdir "zip.t"
+	assert_rant(:x, "-imd5", "zip.t/t4-1.0.0.zip")
+	mf = %w(Rantfile sub/f1 sub2/f1 MANIFEST)
+	dirs = %w(sub sub2)
+	check_contents(:zip, "zip.t/t4-1.0.0.zip", mf, dirs, "MANIFEST")
+	out, err = assert_rant("-imd5", "zip.t/t4-1.0.0.zip")
+        assert(err.empty?)
+        assert(out.empty?)
+	assert_rant("-imd5", "autoclean")
+	assert(test(?d, "zip.t"))
+	assert(!test(?e, ".rant.meta"))
+	assert(!test(?e, "zip.t/t4-1.0.0.zip"))
+    ensure
+	FileUtils.rm_rf "zip.t"
+    end
     def test_zip_from_manifest
 	assert_rant(:x, "t1.zip")
 	mf = %w(Rantfile sub/f1 sub2/f1 MANIFEST)
@@ -432,4 +476,86 @@ class TestImportPackage < Test::Unit::TestCase
 	dirs = %w(sub)
 	check_contents(:zip, "t3.zip", mf, dirs)
     end
+    def write(fn, str)
+        open fn, "w" do |f|
+            f.write str
+        end
+    end
+    def test_md5_zip_package
+        write("sub/pkg.t", "abc\n")
+        write("sub2/a.t", "a\n")
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
+        assert(err.empty?)
+        mf = %w(sub/f1 sub2/f1 sub2/a.t)
+        dirs = %w(sub sub2)
+        @pkg_dir = "m1"
+        check_contents(:zip, "pkg.t/m1.zip", mf, dirs)
+        FileUtils.rm "sub/pkg.t"
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
+        assert(err.empty?)
+        assert(out.empty?)
+        FileUtils.rm "sub2/a.t"
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
+        assert(err.empty?)
+        assert(!out.empty?)
+        mf = %w(sub/f1 sub2/f1)
+        dirs = %w(sub sub2)
+        @pkg_dir = "m1"
+        check_contents(:zip, "pkg.t/m1.zip", mf, dirs)
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("-fmd5.rf", "clean")
+        assert(!test(?e, "pkg.t"))
+        assert(!test(?e, ".rant.meta"))
+    ensure
+        FileUtils.rm_f %w(.rant.meta sub1/pkg.t sub2/a.t)
+    end
+    def test_md5_tgz_package
+        write("sub/pkg.t", "abc\n")
+        write("sub2/a.t", "a\n")
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
+        assert(err.empty?)
+        mf = %w(sub/f1 sub2/f1 sub2/a.t)
+        dirs = %w(sub sub2)
+        @pkg_dir = "m1"
+        check_contents(:tgz, "pkg.t/m1.tgz", mf, dirs)
+        FileUtils.rm "sub/pkg.t"
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
+        assert(err.empty?)
+        assert(out.empty?)
+        FileUtils.rm "sub2/a.t"
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
+        assert(err.empty?)
+        assert(!out.empty?)
+        mf = %w(sub/f1 sub2/f1)
+        dirs = %w(sub sub2)
+        @pkg_dir = "m1"
+        check_contents(:tgz, "pkg.t/m1.tgz", mf, dirs)
+        out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("-fmd5.rf", "clean")
+        assert(!test(?e, "pkg.t"))
+        assert(!test(?e, ".rant.meta"))
+    ensure
+        FileUtils.rm_f %w(.rant.meta sub1/pkg.t sub2/a.t)
+    end
+    def test_rant_import_md5_empty_archive_tgz
+        write("empty.rf", <<-EOF)
+            import "md5", "archive/tgz"
+            gen Archive::Tgz, "empty.t", :files => []
+        EOF
+        run_import("-q", "-fempty.rf", "--auto", "make.t")
+        assert_exit
+        out = run_ruby("make.t", "-fempty.rf", "empty.t.tgz")
+        assert_exit
+        mf = %w()
+        dirs = %w()
+        check_contents(:tgz, "empty.t.tgz", mf, dirs)
+        out = run_ruby("make.t", "-fempty.rf", "empty.t.tgz")
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f %w(make.t empty.rf empty.t.tgz)
+    end
 end

data/test/import/signeddirectory/Rantfile

@@ -0,0 +1,15 @@
+
+import "signedfile", "autoclean"
+
+gen SignedDirectory, "d1.t"
+
+gen SignedDirectory, "d2.t" do |t|
+    sys.touch "#{t.name}/a"
+end
+
+gen SignedDirectory, "d3.t" => sys["{a,b,c}.t"] do |t|
+    sys.rm_f sys["#{t.name}/*"]
+    sys.cp t.prerequisites, t.name
+end
+
+gen AutoClean