archive-tar-external 1.2.1 → 1.2.2

data/CHANGES

@@ -1,3 +1,14 @@
+== 1.2.2 - 28-Jul-2009
+* Compatibility fixes for Ruby 1.9.x and JRuby.
+* Singleton methods that were previously synonyms are now true aliases.
+* License changed to Artistic 2.0.
+* Several gemspec updates, including an updated description, the addition
+  of a license and development dependencies and refactored platform handling.
+* Added test-unit and ptools as development dependencies for the test suite.
+* Some refactoring of the test suite to take advantage of some of the features
+  in test-unit 2.x.
+* Renamed the test file to test_archive_tar_external.rb.
+
 == 1.2.1 - 30-Jul-2007
 * The TarError class is now Tar::Error.
 * Added a Rakefile with tasks for installation and testing.

data/doc/tar_external.txt

@@ -21,7 +21,7 @@
 
 == Constants
 VERSION
-   Current version number of this package.  This is a string.
+   Current version number of this library. This is a string.
 
 == Class Methods
 Archive::Tar::External.new(archive_name, pattern=nil, program=nil)
@@ -119,7 +119,7 @@ Tar::CompressError
    Anything folks are looking for?
 
 == License
-   Ruby's
+   Artistic 2.0
 
 == Warranty
    This package is provided "as is" and without any express or
@@ -127,7 +127,7 @@ Tar::CompressError
    warranties of merchantability and fitness for a particular purpose.
 
 == Copyright
-   (C) 2003 - 2007 Daniel J. Berger
+   (C) 2003 - 2009 Daniel J. Berger
    All Rights Reserved
 
 == Author

data/test/test_archive_tar_external.rb

@@ -0,0 +1,201 @@
+###############################################################################
+# test_archive_tar_external.rb
+#
+# Test suite for the archive-tar-external library. This test case should be
+# run via the 'rake test' Rake task.
+###############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'archive/tar_external'
+require 'test/unit'
+require 'ptools'
+include Archive
+
+class TC_ArchiveTarExternal < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir(File.dirname(File.expand_path(__FILE__)))
+
+      @@tmp_file1 = 'temp1.txt'
+      @@tmp_file2 = 'temp2.txt'
+      @@tmp_file3 = 'temp3.txt'
+
+      @@gtar_found  = File.which('gtar')
+      @@tar_found   = File.which('tar')
+      @@gzip_found  = File.which('gzip')
+      @@bzip2_found = File.which('bzip2')
+
+      File.open(@@tmp_file1, 'w'){ |f| f.puts 'This is a temporary text file' }
+      File.open(@@tmp_file2, 'w'){ |f| f.puts 'This is a temporary text file' }
+      File.open(@@tmp_file3, 'w'){ |f| f.puts 'This is a temporary text file' }
+   end
+
+   def setup
+      @tar      = Tar::External.new('test.tar')
+      @tar_name = 'test.tar'
+      @pattern  = '*.txt'
+      @archive  = 'temp.tar.gz'
+   end
+
+   def test_version
+      assert_equal('1.2.2', Tar::External::VERSION)
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Tar::External.new(@tar_name) }
+   end
+
+   def test_constructor_with_extension
+      assert_nothing_raised{ Tar::External.new(@tar_name, '*.txt') }
+   end
+
+   def test_constructor_with_program
+      omit_unless(@@gzip_found){ 'gzip program not found - skipping' }
+      assert_nothing_raised{ Tar::External.new(@tar_name, '*.txt', 'gzip') }
+   end
+
+   def test_constructor_expected_errors
+      assert_raise(ArgumentError){ Tar::External.new }
+   end
+
+   def test_tar_program
+      assert_respond_to(@tar, :tar_program)
+      assert_equal('tar', @tar.tar_program)
+   end
+
+   def test_archive_name
+      assert_respond_to(@tar, :archive_name)
+      assert_respond_to(@tar, :archive_name=)
+
+      assert_equal('test.tar', @tar.archive_name)
+      assert_nothing_raised{ @tar.archive_name }
+      assert_nothing_raised{ @tar.archive_name = 'foo' }
+   end
+
+   def test_compressed_archive_name_get
+      assert_respond_to(@tar, :compressed_archive_name)
+      assert_nil(@tar.compressed_archive_name)
+   end
+
+   def test_compressed_archive_name_set
+      assert_respond_to(@tar, :compressed_archive_name=)
+      assert_nothing_raised{ @tar.compressed_archive_name = 'test.tar.gz' }
+      assert_equal('test.tar.gz', @tar.compressed_archive_name)
+      assert_equal('test.tar', @tar.archive_name)
+
+      assert_nothing_raised{ @tar.compressed_archive_name = 'test.tgz' }
+      assert_equal('test.tgz', @tar.compressed_archive_name)
+      assert_equal('test.tar', @tar.archive_name)
+   end
+
+   def test_create_archive_basic
+      assert_respond_to(@tar, :create_archive)
+
+      assert_raises(ArgumentError){ @tar.create_archive }
+      assert_raises(Tar::Error){ @tar.create_archive('*.blah') }
+
+      assert_nothing_raised{ @tar.create_archive(@pattern) }
+      assert_true(File.exists?(@tar_name))
+   end
+
+   def test_create_alias
+      assert_respond_to(@tar, :create)
+      assert_true(Tar::External.instance_method(:create) == Tar::External.instance_method(:create_archive))
+   end
+
+   def test_compress_archive_basic
+      assert_respond_to(@tar, :compress_archive)
+   end
+
+   def test_compress_alias
+      assert_respond_to(@tar, :compress)
+      assert_true(Tar::External.instance_method(:compress) == Tar::External.instance_method(:compress_archive))
+   end
+
+   def test_compress_archive_gzip
+      assert_nothing_raised{ @tar.create_archive('*.txt') }
+      assert_nothing_raised{ @tar.compress_archive }
+
+      assert_equal('test.tar.gz', @tar.compressed_archive_name)
+      assert_true(File.exists?('test.tar.gz'))
+   end
+
+   def test_compress_archive_bzip2
+      assert_nothing_raised{ @tar.create_archive('*.txt') }
+      assert_nothing_raised{ @tar.compress_archive('bzip2') }
+      assert_true(File.exists?('test.tar.bz2'))
+   end
+
+   def test_uncompress_archive
+      assert_respond_to(@tar, :uncompress_archive)
+      assert_nothing_raised{ @tar.create_archive('*.txt') }
+      assert_nothing_raised{ @tar.compress_archive }
+      assert_nothing_raised{ @tar.uncompress_archive }
+      assert_false(File.exists?('test.tar.gz'))
+   end
+
+   def test_uncompress_archive_class_method
+      assert_respond_to(Tar::External, :uncompress_archive)
+   end
+
+   def test_uncompress_alias
+      assert_respond_to(Tar::External, :uncompress)
+      assert_true(Tar::External.method(:uncompress) == Tar::External.method(:uncompress_archive))
+   end
+
+   def test_archive_info
+      assert_respond_to(@tar, :archive_info)
+      assert_nothing_raised{ @tar.create_archive('*.txt') }
+      assert_equal(['temp1.txt','temp2.txt','temp3.txt'], @tar.archive_info)
+   end
+
+   def test_add_to_archive
+      assert_respond_to(@tar,:add_to_archive)
+      assert_nothing_raised{ @tar.create_archive('temp1.txt') }
+      assert_nothing_raised{ @tar.add_to_archive('temp2.txt') }
+      assert_nothing_raised{ @tar.add_to_archive('temp2.txt','temp3.txt') }
+   end
+
+   def test_update_archive
+      assert_respond_to(@tar, :update_archive)
+      assert_nothing_raised{ @tar.create_archive('*.txt') }
+      assert_nothing_raised{ @tar.update_archive('temp2.txt') }
+   end
+
+   def test_extract_archive_basic
+      assert_respond_to(@tar, :extract_archive)
+   end
+
+   def test_extract_archive_aliases
+      assert_true(Tar::External.instance_method(:extract_archive) == Tar::External.instance_method(:expand_archive)) 
+      assert_true(Tar::External.instance_method(:extract) == Tar::External.instance_method(:expand_archive)) 
+      assert_true(Tar::External.instance_method(:expand) == Tar::External.instance_method(:expand_archive)) 
+   end
+
+   def test_extract_archive_advanced
+      assert_nothing_raised{ @tar.tar_program = @@gtar } if Config::CONFIG['host_os'] =~ /sunos|solaris/i
+      assert_nothing_raised{ @tar.create('*.txt') }
+      assert_raises(Tar::Error){ @tar.expand('blah.txt') }
+
+      assert_nothing_raised{ @tar.extract_archive }
+      assert_nothing_raised{ @tar.extract_archive('temp2.txt') }
+   end
+
+   def teardown
+      @tar = nil
+      File.delete('test.tar') if File.exists?('test.tar')
+      File.delete('test.tar.gz') if File.exists?('test.tar.gz')
+      File.delete('test.tar.bz2') if File.exists?('test.tar.bz2')
+      File.delete('test.tar.zip') if File.exists?('test.tar.zip')
+   end
+
+   def self.shutdown
+      @@tar_foudn   = nil
+      @@gzip_found  = nil
+      @@bzip2_found = nil
+
+      File.delete(@@tmp_file1) if File.exists?(@@tmp_file1)
+      File.delete(@@tmp_file2) if File.exists?(@@tmp_file2)
+      File.delete(@@tmp_file3) if File.exists?(@@tmp_file3)
+   end
+end

metadata

@@ -1,58 +1,81 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: archive-tar-external
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
-date: 2007-07-30 00:00:00 -06:00
-summary: A simple way to create tar archives using external calls
-require_paths: 
-- lib
-email: djberg96@gmail.com
-homepage: http://www.rubyforge.org/shards
-rubyforge_project: 
-description: A simple way to create tar archives using external calls
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.2.2
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Daniel Berger
-files: 
-- doc/tar_external.txt
-- lib/archive
-- lib/archive/tar_external.rb
-- test/tc_archive.rb
-- test/temp1.txt
-- test/temp2.txt
-- test/temp3.txt
-- README
-- CHANGES
-- MANIFEST
-test_files: 
-- test/tc_archive.rb
-rdoc_options: []
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-28 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ptools
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
+    version: 
+description: "      The archive-tar-external is a simple wrapper interface for creating\n      tar files using your system's tar command. You can also easily compress\n      your tar files with your system's compression programs such as zip, gzip,\n      or bzip2.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
 
 extra_rdoc_files: 
 - README
 - CHANGES
 - MANIFEST
 - doc/tar_external.txt
-executables: []
-
-extensions: []
+files: 
+- doc/tar_external.txt
+- test/test_archive_tar_external.rb
+- README
+- CHANGES
+- MANIFEST
+has_rdoc: true
+homepage: http://www.rubyforge.org/shards
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: shards
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A simple way to create tar archives using external calls
+test_files: 
+- test/test_archive_tar_external.rb

data/lib/archive/tar_external.rb

@@ -1,287 +0,0 @@
-if RUBY_PLATFORM.match('mswin')
-   require 'win32/open3'
-else
-   require 'open3'
-end
-
-# The Archive module serves as a namespace only.
-module Archive
-
-   # The Tar class serves as a toplevel class namespace only.
-   class Tar
-
-      # Raised if something goes wrong during the execution of any methods
-      # which use the tar command internally.
-      class Error < StandardError; end
-
-      # Raised if something goes wrong during the Tar#compress_archive or
-      # Tar#uncompress_archive methods.      
-      class CompressError < StandardError; end
-
-      # This class encapsulates tar & zip operations.
-      class Tar::External
-         VERSION = '1.2.1'
-
-         # The name of the archive file to be used, e.g. "test.tar"
-         attr_accessor :archive_name
-
-         # The name of the tar program you wish to use.  The default is "tar".
-         attr_accessor :tar_program
-
-         # The name of the archive file after compression, e.g. "test.tar.gz"
-         attr_reader :compressed_archive_name
-
-         # Returns an Archive::Tar::External object.  The +archive_name+ is the
-         # name of the tarball.  While a .tar extension is recommended based on
-         # years of convention, it is not enforced.
-         #
-         # Note that this does not actually create the archive unless you
-         # pass a value to +file_pattern+.  This then becomes a shortcut for
-         # Archive::Tar::External.new + Archive::Tar::External#create_archive.
-         #
-         # If +program+ is provided, then it compresses the archive as well by
-         # calling Archive::Tar::External#compress_archive internally.
-         #
-         def initialize(archive_name, file_pattern=nil, program=nil)
-            @archive_name            = archive_name.to_s
-            @compressed_archive_name = nil
-            @tar_program             = "tar"
-
-            if file_pattern
-               create_archive(file_pattern)
-            end
-
-            if program
-               compress_archive(program)
-            end
-         end
-
-         # Assign a compressed archive name.  This autogenerates the archive_name
-         # based on the extension of the name provided, unless you provide the
-         # extension yourself.  If the extension is '.tgz', then the base of the
-         # name + '.tar' will be the new archive name.
-         #
-         # This should only be used if you have a pre-existing, compressed archive
-         # that you want to uncompress, and want to have a Tar::External object
-         # around.  Otherwise, use the class method Tar::External.uncompress.
-         #
-         def compressed_archive_name=(name, ext=File.extname(name))
-            if ext == '.tgz' || ext == '.TGZ'
-               @archive_name = File.basename(name, ext.downcase) + '.tar'
-            else
-               @archive_name = File.basename(name, ext)
-            end
-            @compressed_archive_name = name
-         end
-
-         # Creates the archive using +file_pattern+.  Any errors that occur
-         # here will raise a Error.
-         #
-         def create_archive(file_pattern)
-            cmd = "#{@tar_program} cf #{@archive_name} #{file_pattern}"
-            Open3.popen3(cmd){ |tar_in, tar_out, tar_err|
-               err = tar_err.gets
-               if err
-                  raise Error, err.chomp
-               end
-            }
-            self
-         end
-         alias :create :create_archive
-
-         # Compresses the archive with +program+, or gzip if no program is
-         # provided.  If you want to pass arguments to +program+, merely include
-         # them as part of the program name, e.g. "gzip -f".
-         #
-         # Any errors that occur here will raise a Tar::CompressError.
-         #
-         def compress_archive(program="gzip")
-            cmd = "#{program} #{@archive_name}"
-            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-               err = prog_err.gets 
-               if err
-                  raise CompressError, err.chomp
-               end
-
-               # Find the new file name with the extension.  There's probably a more
-               # reliable way to do this, but this should work 99% of the time.
-               name = Dir["#{@archive_name}.{gz,bz2,cpio,zip}"].first
-               @compressed_archive_name = name
-            }
-            self
-         end
-         alias :compress :compress_archive
-
-         # Uncompresses the tarball using the program you pass to this method.  The
-         # default is "gunzip".  Just as for +compress_archive+, you can pass
-         # arguments along as part of the argument.
-         #
-         # Note that this is only for use with archives that have been zipped up
-         # with gunzip, or whatever.  If you want to *extract* the files from the
-         # tarball, use Tar::External#extract instead.
-         #
-         # Any errors that occur here will raise a Tar::CompressError.
-         #
-         def uncompress_archive(program="gunzip")
-            unless @compressed_archive_name
-               raise CompressError, "no compressed file found"
-            end
-               
-            cmd = "#{program} #{@compressed_archive_name}"
-
-            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-               err = prog_err.gets
-               if err
-                  raise CompressError, err.chomp
-               end
-               @compressed_archive_name = nil
-            }
-            self
-         end
-         alias :uncompress :uncompress_archive
-
-         # Uncompress an existing archive, using +program+ to uncompress it.
-         # The default decompression program is gunzip.
-         #
-         def self.uncompress_archive(archive, program='gunzip')
-            cmd = "#{program} #{archive}"
-
-            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-               err = prog_err.gets
-               if err
-                  raise CompressError, err.chomp
-               end
-            }
-         end
-
-         # An alias for Tar::External.uncompress_archive.
-         #
-         def self.uncompress(file, program='gunzip')
-            self.uncompress_archive(file, program)
-         end
-
-         # Returns an array of file names that are included within the tarball.
-         # This method does not extract the archive.
-         #
-         def archive_info
-            result = []
-            cmd = "#{@tar_program} tf #{@archive_name}"
-            Open3.popen3(cmd){ |ain, aout, aerr|
-               err = aerr.gets
-               if err
-                  raise Error, err.chomp
-               end
-
-               while output = aout.gets
-                  result << output.chomp
-               end
-            }
-            result
-         end
-         alias :info :archive_info
-
-         # Adds +files+ to an already existing archive.
-         #
-         def add_to_archive(*files)
-            if files.empty?
-               raise Error, "there must be at least one file specified"
-            end
-
-            cmd = "#{@tar_program} rf #{@archive_name} #{files.join(" ")}"
-            Open3.popen3(cmd){ |ain, aout, aerr|
-               err = aerr.gets
-
-               if err
-                  raise Error, err.chomp
-               end
-            }
-            self
-         end
-         alias :add :add_to_archive
-
-         # Updates the given +files+ in the archive, i.e. they are added if they
-         # are not already in the archive or have been modified.
-         #
-         def update_archive(*files)
-            if files.empty?
-               raise Error, "there must be at least one file specified"
-            end
-
-            cmd = "#{@tar_program} uf #{@archive_name} #{files.join(" ")}"
-
-            Open3.popen3(cmd){ |ain, aout, aerr|
-               err = aerr.gets
-               if err
-                  raise Error, err.chomp
-               end
-            }
-            self
-         end
-         alias :update :update_archive
-
-         # Expands the contents of the tarball.  It does NOT delete the tarball.
-         # If +files+ are provided, then only those files are extracted.
-         # Otherwise, all files are extracted.
-         #
-         # Note that some tar programs, notably the tar program shipped by Sun,
-         # does not issue any sort of warning or error if you try to extract a
-         # file that does not exist in the archive.
-         #
-         def extract_archive(*files)
-            cmd = "#{@tar_program} xf #{@archive_name}"
-
-            unless files.empty?
-               cmd << " " << files.join(" ")
-            end
-
-            Open3.popen3(cmd){ |ain, aout, aerr|
-               err = aerr.gets
-
-               if err
-                  raise Error, err.chomp
-               end
-            }
-            self
-         end
-         alias :expand_archive :extract_archive
-         alias :extract :extract_archive
-         alias :expand :extract_archive
-
-         # A class method that behaves identically to the equivalent instance
-         # method, except that you must specifiy that tarball as the first
-         # argument. Also, the tar program is hard coded to 'tar xf'.
-         #
-         def self.extract_archive(archive, *files)
-            cmd = "tar xf #{archive}"
-
-            unless files.empty?
-               cmd << " " << files.join(" ")
-            end
-
-            Open3.popen3(cmd){ |ain, aout, aerr|
-               err = aerr.gets
-
-               if err
-                  raise Error, err.chomp
-               end
-            }
-            self
-         end
-
-         # Alias for self.extract_archive
-         def self.expand_archive(*args)
-            self.extract_archive(*args)
-         end
-
-         # Alias for self.extract_archive
-         def self.extract(*args)
-            self.extract_archive(*args)
-         end
-
-         # Alias for self.extract_archive
-         def self.expand(*args)
-            self.extract_archive(*args)
-         end
-      end
-   end
-end

data/test/tc_archive.rb

@@ -1,153 +0,0 @@
-###############################################################################
-# tc_archive.rb
-#
-# Test suite for the archive-tarsimple package. This test case should be
-# run via the 'rake test' Rake task.
-###############################################################################
-require 'archive/tar_external'
-require 'test/unit'
-include Archive
-
-class TC_Archive < Test::Unit::TestCase
-   def setup
-      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
-      @t        = Tar::External.new('test.tar')
-      @tar_name = 'test.tar'
-      @pattern  = '*.txt'
-      @archive  = 'temp.tar.gz'
-   end
-
-   def test_version
-      assert_equal('1.2.1', Tar::External::VERSION)
-   end
-
-   def test_constructor
-      assert_nothing_raised{ Tar::External.new(@tar_name) }
-      assert_nothing_raised{ Tar::External.new(@tar_name, '*.txt') }
-      assert_raises(ArgumentError){ Tar::External.new }
-   end
-
-   def test_tar_program
-      assert_respond_to(@t, :tar_program)
-      assert_equal('tar', @t.tar_program)
-   end
-
-   def test_archive_name
-      assert_respond_to(@t, :archive_name)
-      assert_respond_to(@t, :archive_name=)
-
-      assert_equal('test.tar', @t.archive_name)
-      assert_nothing_raised{ @t.archive_name }
-      assert_nothing_raised{ @t.archive_name = 'foo' }
-   end
-
-   def test_compressed_archive_name_get
-      assert_respond_to(@t, :compressed_archive_name)
-      assert_nil(@t.compressed_archive_name)
-   end
-
-   def test_compressed_archive_name_set
-      assert_respond_to(@t, :compressed_archive_name=)
-      assert_nothing_raised{ @t.compressed_archive_name = 'test.tar.gz' }
-      assert_equal('test.tar.gz', @t.compressed_archive_name)
-      assert_equal('test.tar', @t.archive_name)
-
-      assert_nothing_raised{ @t.compressed_archive_name = 'test.tgz' }
-      assert_equal('test.tgz', @t.compressed_archive_name)
-      assert_equal('test.tar', @t.archive_name)
-   end
-
-   def test_create_archive_basic
-      assert_respond_to(@t, :create_archive)
-      assert_respond_to(@t, :create) # Alias
-
-      assert_raises(ArgumentError){ @t.create_archive }
-      assert_raises(Tar::Error){ @t.create_archive('*.blah') }
-
-      assert_nothing_raised{ @t.create_archive(@pattern) }
-      assert(@t.create_archive(@pattern))
-      assert(File.exists?(@tar_name))
-   end
-
-   def test_compress_archive_basic
-      assert_respond_to(@t, :compress_archive)
-      assert_respond_to(@t, :compress) # Alias
-   end
-
-   def test_compress_archive_gzip
-      assert_nothing_raised{ @t.create_archive('*.txt') }
-      assert_nothing_raised{ @t.compress_archive }
-
-      assert_equal('test.tar.gz', @t.compressed_archive_name)
-      assert(File.exists?('test.tar.gz'))
-   end
-
-   def test_compress_archive_bzip2
-      assert_nothing_raised{ @t.create_archive('*.txt') }
-      assert_nothing_raised{ @t.compress_archive('bzip2') }
-      assert(File.exists?('test.tar.bz2'))
-   end
-
-   def test_uncompress_archive
-      assert_respond_to(@t, :uncompress_archive)
-      assert_nothing_raised{ @t.create_archive('*.txt') }
-      assert_nothing_raised{ @t.compress_archive }
-      assert_nothing_raised{ @t.uncompress_archive }
-      assert(!File.exists?('test.tar.gz'))
-   end
-
-   def test_uncompress_archive_class_method
-      assert_respond_to(Tar::External, :uncompress_archive)
-      assert_respond_to(Tar::External, :uncompress)
-   end
-
-   def test_archive_info
-      assert_respond_to(@t, :archive_info)
-      assert_nothing_raised{ @t.create_archive('*.txt') }
-      assert_equal(['temp1.txt','temp2.txt','temp3.txt'], @t.archive_info)
-   end
-
-   def test_add_to_archive
-      assert_respond_to(@t,:add_to_archive)
-      assert_nothing_raised{ @t.create_archive('temp1.txt') }
-      assert_nothing_raised{ @t.add_to_archive('temp2.txt') }
-      assert_nothing_raised{ @t.add_to_archive('temp2.txt','temp3.txt') }
-   end
-
-   def test_update_archive
-      assert_respond_to(@t, :update_archive)
-      assert_nothing_raised{ @t.create_archive('*.txt') }
-      assert_nothing_raised{ @t.update_archive('temp2.txt') }
-   end
-
-   def test_extract_archive_basic
-      assert_respond_to(@t, :extract_archive)
-      assert_respond_to(@t, :expand_archive) # Alias
-      assert_respond_to(@t, :extract)        # Alias
-      assert_respond_to(@t, :expand)         # Alias
-   end
-
-   def test_extract_archive_advanced
-      @t.tar_program = 'gtar' if PLATFORM.match('solaris')
-      assert_nothing_raised{ @t.create('*.txt') }
-      assert_raises(Tar::Error){ @t.expand('blah.txt') }
-
-      assert_nothing_raised{ @t.extract_archive }
-      assert_nothing_raised{ @t.extract_archive('temp2.txt') }
-   end
-
-   def test_extract_archive_class_method
-      assert_respond_to(Tar::External, :extract_archive)
-      assert_respond_to(Tar::External, :expand_archive)
-      assert_respond_to(Tar::External, :extract)
-      assert_respond_to(Tar::External, :expand)
-   end
-
-   def teardown
-      @t = nil
-      File.unlink('test.tar') if File.exists?('test.tar')
-      File.unlink('test.tar.gz') if File.exists?('test.tar.gz')
-      File.unlink('test.tar.bz2') if File.exists?('test.tar.bz2')
-      File.unlink('test.tar.zip') if File.exists?('test.tar.zip')
-   end
-end

data/test/temp1.txt

@@ -1 +0,0 @@
-This is a temporary text file

data/test/temp2.txt

@@ -1,4 +0,0 @@
-This is a temporary text file
-It is only used for testing
-It is only used for testing
-Feel free to delete these later

data/test/temp3.txt

@@ -1,3 +0,0 @@
-This is a temporary text file
-It is only used for testing
-Feel free to delete these later