pr-zlib 1.0.0

data/test/test_zlib_deflate.rb

@@ -0,0 +1,58 @@
+########################################################################
+# test_zlib_deflate.rb
+#
+# Test case for the Zlib::Deflate class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/zlib'
+require 'test/unit'
+
+class TC_Zlib_Deflate < Test::Unit::TestCase
+   def self.startup
+   end
+
+   def setup
+      @deflate = Zlib::Deflate.new
+   end
+
+   def test_deflate_run_singleton_basic
+      assert_respond_to(Zlib::Deflate, :deflate_run)
+   end
+
+   def test_deflate_singleton_basic
+      assert_respond_to(Zlib::Deflate, :deflate)
+   end
+
+   #def test_initialize_copy_basic
+      #assert_respond_to(@deflate, :initialize_copy)
+   #end
+
+   def test_deflate_basic
+      assert_respond_to(@deflate, :deflate)
+   end
+
+   def test_append_basic
+      assert_respond_to(@deflate, :<<)
+   end
+
+   def test_flush_basic
+      assert_respond_to(@deflate, :flush)
+   end
+
+   def test_params_basic
+      assert_respond_to(@deflate, :params)
+   end
+
+   def test_set_dictionary_basic
+      assert_respond_to(@deflate, :set_dictionary)
+   end
+
+   def teardown
+      @deflate = nil
+   end
+
+   def self.shutdown
+   end
+end

data/test/test_zlib_gzip_file.rb

@@ -0,0 +1,96 @@
+########################################################################
+# test_zlib_gzip_file.rb
+#
+# Test case for the Zlib::GzipFile base class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/zlib'
+require 'test/unit'
+
+class TC_Zlib_GzipFile < Test::Unit::TestCase
+   def self.startup
+   end
+
+   def setup
+      @gz_file = Zlib::GzipFile.new
+   end
+
+   def test_gzip_file_constants
+      assert_equal(Zlib::GzipFile::GZ_MAGIC1, 0x1f)
+      assert_equal(Zlib::GzipFile::GZ_MAGIC2, 0x8b)
+      assert_equal(Zlib::GzipFile::GZ_METHOD_DEFLATE, 8)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_MULTIPART, 0x2)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_EXTRA, 0x4)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_ORIG_NAME, 0x8)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_COMMENT, 0x10)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_ENCRYPT, 0x20)
+      assert_equal(Zlib::GzipFile::GZ_FLAG_UNKNOWN_MASK, 0xc0)
+      assert_equal(Zlib::GzipFile::GZ_EXTRAFLAG_FAST, 0x4)
+      assert_equal(Zlib::GzipFile::GZ_EXTRAFLAG_SLOW, 0x2)
+   end
+
+   def test_gzfile_is_finished
+      assert_respond_to(@gz_file, :GZFILE_IS_FINISHED)
+   end
+
+   def test_gzfile_close_basic
+      assert_respond_to(@gz_file, :gzfile_close)
+   end
+
+   def test_to_io_basic
+      assert_respond_to(@gz_file, :to_io)
+   end
+
+   def test_crc_basic
+      assert_respond_to(@gz_file, :crc)
+   end
+
+   def test_mtime_basic
+      assert_respond_to(@gz_file, :mtime)
+   end
+
+   def test_level_basic
+      assert_respond_to(@gz_file, :level)
+   end
+
+   def test_os_code_basic
+      assert_respond_to(@gz_file, :os_code)
+   end
+
+   def test_orig_name_basic
+      assert_respond_to(@gz_file, :orig_name)
+   end
+
+   def test_comment_basic
+      assert_respond_to(@gz_file, :comment)
+   end
+
+   def test_close_basic
+      assert_respond_to(@gz_file, :close)
+   end
+
+   def test_finish_basic
+      assert_respond_to(@gz_file, :finish)
+   end
+
+   def test_is_closed_basic
+      assert_respond_to(@gz_file, :closed?)
+   end
+
+   def test_sync_get_basic
+      assert_respond_to(@gz_file, :sync)
+   end
+
+   def test_sync_set_basic
+      assert_respond_to(@gz_file, :sync=)
+   end
+
+   def teardown
+      @gz_file = nil
+   end
+
+   def self.shutdown
+   end
+end

data/test/test_zlib_gzip_reader.rb

@@ -0,0 +1,184 @@
+########################################################################
+# test_zlib_gzip_reader.rb
+#
+# Tests for the GzipReader class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'fileutils'
+require 'pr/zlib'
+
+class TC_GzipReader < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.basename(Dir.pwd) != 'test'
+      File.open('test.txt', 'wb'){ |fh| fh.puts 'Test file' }
+      system('gzip *.txt')
+      @@gz_file = 'test.txt.gz'
+   end
+
+   def setup
+      @handle = File.open(@@gz_file)
+      @gz_reader = Zlib::GzipReader.new(@handle)
+   end
+
+   def test_constructor_expected_errors
+      assert_raise(ArgumentError){ Zlib::GzipReader.new }
+      assert_raise(NoMethodError){ Zlib::GzipReader.new(1) }
+   end
+
+   def test_lineno_get_basic
+      assert_respond_to(@gz_reader, :lineno)
+      assert_nothing_raised{ @gz_reader.lineno }
+   end
+
+   def test_lineno_get
+      assert_kind_of(Fixnum, @gz_reader.lineno)
+      assert_equal(0, @gz_reader.lineno)
+   end
+
+   def test_lineno_set_basic
+      assert_respond_to(@gz_reader, :lineno=)
+      assert_nothing_raised{ @gz_reader.lineno = 0 }
+   end
+
+   def test_lineno_set
+      assert_kind_of(Fixnum, @gz_reader.lineno = 0)
+      assert_equal(0, @gz_reader.lineno = 0)
+   end
+
+   def test_eof_basic
+      assert_respond_to(@gz_reader, :eof)
+      assert_nothing_raised{ @gz_reader.eof }
+   end
+
+   def test_pos_basic
+      assert_respond_to(@gz_reader, :pos)
+      assert_nothing_raised{ @gz_reader.pos }
+   end
+
+   def test_pos
+      assert_kind_of(Fixnum, @gz_reader.pos)
+   end
+
+   def test_rewind_basic
+      assert_respond_to(@gz_reader, :rewind)
+      assert_nothing_raised{ @gz_reader.rewind }
+   end
+
+   def test_rewind
+      assert_equal(0, @gz_reader.rewind)
+   end
+
+   def test_unused_basic
+      assert_respond_to(@gz_reader, :unused)
+      assert_nothing_raised{ @gz_reader.unused }
+   end
+
+   def test_unused
+      assert_nil(@gz_reader.unused)
+   end
+
+   def test_read_basic
+      assert_respond_to(@gz_reader, :read)
+      assert_nothing_raised{ @gz_reader.read }
+   end
+
+   def test_read
+      assert_equal("Test file\n", @gz_reader.read)
+   end
+
+   def test_read_with_length
+      assert_equal("Test", @gz_reader.read(4))
+   end
+
+   def test_read_expected_errors
+      assert_raise(ArgumentError){ @gz_reader.read(-1) }
+   end
+   
+   def test_getc_basic
+      assert_respond_to(@gz_reader, :getc)
+      assert_nothing_raised{ @gz_reader.getc }
+   end
+
+   def test_getc
+      assert_equal(84, @gz_reader.getc)
+   end
+
+   def test_readchar_basic
+      assert_respond_to(@gz_reader, :readchar)
+      assert_nothing_raised{ @gz_reader.readchar }
+   end
+
+   def test_readchar
+      assert_equal(84, @gz_reader.readchar)
+   end
+
+   def test_each_byte_basic
+      assert_respond_to(@gz_reader, :each_byte)
+      assert_nothing_raised{ @gz_reader.each_byte{} }
+   end
+
+   def test_each_byte
+      assert_nil(@gz_reader.each_byte{})
+   end
+
+   def test_ungetc_basic
+      assert_respond_to(@gz_reader, :ungetc)
+      assert_nothing_raised{ @gz_reader.ungetc(99) }
+   end
+
+   def test_ungetc
+      assert_nil(@gz_reader.ungetc(99))
+   end
+
+   def test_gets_basic
+      assert_respond_to(@gz_reader, :gets)
+      assert_nothing_raised{ @gz_reader.gets }
+   end
+
+   def test_gets
+      assert_equal("Test file\n", @gz_reader.gets)
+      omit('Skipping $_ test')
+      assert_equal("Test file\n", $_)
+   end
+
+   def test_readline_basic
+      assert_respond_to(@gz_reader, :readline)
+      assert_nothing_raised{ @gz_reader.readline } 
+   end
+
+   def test_readline
+      assert_equal("Test file\n", @gz_reader.readline)
+   end
+
+   def test_each_basic
+      assert_respond_to(@gz_reader, :each)
+      assert_nothing_raised{ @gz_reader.each{} }
+   end
+
+   def test_each
+      assert_not_nil(@gz_reader.each{})
+   end
+
+   def test_readlines_basic
+      assert_respond_to(@gz_reader, :readlines)
+      assert_nothing_raised{ @gz_reader.readlines }
+   end
+
+   def test_readlines
+      assert_equal(["Test file\n"], @gz_reader.readlines)
+   end
+
+   def teardown
+      @handle.close if @handle && !@handle.closed?
+      @handle = nil
+      @gz_reader = nil
+   end
+
+   def self.shutdown
+      File.delete(@@gz_file) if File.exists?(@@gz_file)
+      @@gz_file = nil
+   end
+end

data/test/test_zlib_gzip_writer.rb

@@ -0,0 +1,188 @@
+########################################################################
+# test_zlib_gzip_writer.rb
+#
+# Test case for the Zlib::GzipWriter class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/zlib'
+require 'test/unit'
+
+class TC_Zlib_GzipWriter < Test::Unit::TestCase
+   def self.startup
+      @@file = 'gzip_writer_test.gz'
+   end
+
+   def setup
+      @handle = File.new(@@file, 'w')
+      @writer = Zlib::GzipWriter.new(@handle)
+      @time   = Time.now
+   end
+
+   def test_constructor
+      assert_nothing_raised{ @writer = Zlib::GzipWriter.new(@handle) }
+   end
+
+   def test_constructor_expected_errors
+      assert_raise(ArgumentError){ Zlib::GzipWriter.new }
+   end
+
+   def test_level
+      assert_respond_to(@writer, :level)
+      assert_equal(Z_DEFAULT_COMPRESSION, @writer.level)
+   end
+
+   def test_mtime_get_basic
+      assert_respond_to(@writer, :mtime)
+      assert_nothing_raised{ @writer.mtime }
+   end
+
+   def test_mtime_get
+      assert_kind_of(Time, @writer.mtime)
+      assert_equal(Time.at(0), @writer.mtime)
+   end
+
+   def test_mtime_set_basic
+      assert_respond_to(@writer, :mtime=)
+      assert_nothing_raised{ @writer.mtime = @time }
+   end
+
+   def test_mtime_set
+      assert_equal(@time, @writer.mtime = @time)
+   end
+
+   def test_orig_name_get_basic
+      assert_respond_to(@writer, :orig_name)
+      assert_nothing_raised{ @writer.orig_name }
+   end
+
+   def test_orig_name_get
+      assert_nil(@writer.orig_name)
+   end
+
+   def test_orig_name_set_basic
+      assert_respond_to(@writer, :orig_name=)
+      assert_nothing_raised{ @writer.orig_name = 'test' }
+   end
+
+   def test_orig_name_set
+      assert_equal('test', @writer.orig_name = 'test')
+      assert_equal('test', @writer.orig_name)
+   end
+
+   def test_comment_get_basic
+      assert_respond_to(@writer, :comment)
+      assert_nothing_raised{ @writer.comment }
+   end
+
+   def test_comment_get
+      assert_nil(@writer.comment)
+   end
+
+   def test_comment_set_basic
+      assert_respond_to(@writer, :comment=)
+      assert_nothing_raised{ @writer.comment = 'test' }
+   end
+
+   def test_comment_set
+      assert_equal('test', @writer.comment = 'test')
+      assert_equal('test', @writer.comment)
+   end
+
+   def test_pos_basic
+      assert_respond_to(@writer, :pos)
+      assert_nothing_raised{ @writer.pos }
+      assert_kind_of(Fixnum, @writer.pos)
+   end
+
+   def test_pos
+      assert_equal(0, @writer.pos)
+      assert_nothing_raised{ @writer.write('test') }
+      assert_equal(4, @writer.pos)
+   end
+
+   def test_tell_alias
+      assert_true(Zlib::GzipWriter.instance_method(:pos) == Zlib::GzipWriter.instance_method(:tell))
+   end
+
+   def test_open_basic
+      assert_respond_to(Zlib::GzipWriter, :open)
+      assert_nothing_raised{ Zlib::GzipWriter.open(@@file){} }
+   end
+
+   def test_flush_basic
+      assert_respond_to(@writer, :flush)
+      assert_nothing_raised{ @writer.flush }
+   end
+
+   def test_flush
+      assert_equal(@writer, @writer.flush)
+   end
+
+   def test_write_basic
+      assert_respond_to(@writer, :write)
+      assert_nothing_raised{ @writer.write('test') }
+   end
+
+   def test_write
+      assert_equal(4, @writer.write('test'))
+      assert_equal(3, @writer.write(999))
+   end
+
+   def test_write_expected_errors
+      assert_raise(ArgumentError){ @writer.write }
+   end
+
+   def test_putc_basic
+      assert_respond_to(@writer, :putc)
+      assert_nothing_raised{ @writer.putc(97) }
+   end
+
+   def test_putc
+      assert_equal(97, @writer.putc(97))
+   end
+
+   def test_putc_expected_errors
+      assert_raise(ArgumentError){ @writer.putc }
+      assert_raise(NoMethodError){ @writer.putc('a') }
+   end
+
+   def test_append_basic
+      assert_respond_to(@writer, :<<)
+      assert_nothing_raised{ @writer << 'test' }
+   end
+
+   def test_append_expected_errors
+      assert_raise(ArgumentError){ @writer.send(:<<) }
+   end
+
+   def test_printf_basic
+      assert_respond_to(@writer, :printf)
+      assert_nothing_raised{ @writer.printf('%s', 'test') }
+   end
+
+   def test_printf_expected_errors
+      assert_raise(ArgumentError){ @writer.printf }
+   end
+
+   def test_puts_basic
+      assert_respond_to(@writer, :puts)
+      assert_nothing_raised{ @writer.puts('test') }
+   end
+
+   def test_puts_expected_errors
+      assert_raise(ArgumentError){ @writer.puts }
+      assert_raise(ArgumentError){ @writer.puts('test1', 'test2') }
+   end
+
+   def teardown
+      @handle.close if @handle && !@handle.closed?
+      @handle = nil
+      @time = nil
+   end
+
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+   end
+end