pr-zlib 1.0.0 → 1.0.1

data/test/test_rbzlib_bytef.rb

@@ -3,15 +3,12 @@
 #
 # Test case for the Zlib::Bytef class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
 require 'pr/rbzlib'
-require 'test/unit'
+require 'test-unit'
 
 class TC_Rbzlib_Bytef < Test::Unit::TestCase
    def setup
-      @buffer = 0.chr * 32 
+      @buffer = 0.chr * 32
       @bytef  = Rbzlib::Bytef.new(@buffer)
    end
 

data/test/test_rbzlib_posf.rb

@@ -3,11 +3,8 @@
 #
 # Test case for the Zlib::Posf class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
 require 'pr/rbzlib'
-require 'test/unit'
+require 'test-unit'
 
 class TC_Rbzlib_Posf < Test::Unit::TestCase
    def setup

data/test/test_zlib.rb

@@ -3,10 +3,7 @@
 #
 # Test case for the Zlib module.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'pr/zlib'
 
 class TC_Zlib < Test::Unit::TestCase
@@ -24,7 +21,7 @@ class TC_Zlib < Test::Unit::TestCase
 
    def test_zlib_version
       assert_equal('1.2.3', Zlib::ZLIB_VERSION)
-      assert_equal('1.0.0', Zlib::PR_ZLIB_VERSION)
+      assert_equal('1.0.1', Zlib::PR_ZLIB_VERSION)
    end
 
    def test_zlib_included_constants

data/test/test_zlib_deflate.rb

@@ -3,11 +3,8 @@
 #
 # Test case for the Zlib::Deflate class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
 require 'pr/zlib'
-require 'test/unit'
+require 'test-unit'
 
 class TC_Zlib_Deflate < Test::Unit::TestCase
    def self.startup

data/test/test_zlib_gzip_file.rb

@@ -3,11 +3,8 @@
 #
 # Test case for the Zlib::GzipFile base class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
 require 'pr/zlib'
-require 'test/unit'
+require 'test-unit'
 
 class TC_Zlib_GzipFile < Test::Unit::TestCase
    def self.startup

data/test/test_zlib_gzip_reader.rb

@@ -3,182 +3,181 @@
 #
 # Tests for the GzipReader class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require '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
+  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
+    expected = RUBY_VERSION.to_f >= 1.9 ? 'T' : 84
+    assert_equal(expected, @gz_reader.getc)
+  end
+
+  def test_readchar_basic
+    assert_respond_to(@gz_reader, :readchar)
+    assert_nothing_raised{ @gz_reader.readchar }
+  end
+
+  def test_readchar
+    expected = RUBY_VERSION.to_f >= 1.9 ? 'T' : 84
+    assert_equal(expected, @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.exist?(@@gz_file)
+    @@gz_file = nil
+  end
 end

data/test/test_zlib_gzip_writer.rb

@@ -3,186 +3,182 @@
 #
 # Test case for the Zlib::GzipWriter class.
 ########################################################################
-require 'rubygems'
-gem 'test-unit'
-
 require 'pr/zlib'
-require 'test/unit'
+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
+  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_alias_method(@writer, :pos, :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 }
+  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.exist?(@@file)
+  end
 end