pr-zlib 1.0.5 → 1.1.0

data/test/test_zlib_gzip_file.rb

@@ -1,93 +0,0 @@
-########################################################################
-# test_zlib_gzip_file.rb
-#
-# Test case for the Zlib::GzipFile base class.
-########################################################################
-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

@@ -1,183 +0,0 @@
-########################################################################
-# test_zlib_gzip_reader.rb
-#
-# Tests for the GzipReader class.
-########################################################################
-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(Integer, @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(Integer, @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(Integer, @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

@@ -1,186 +0,0 @@
-########################################################################
-# test_zlib_gzip_writer.rb
-#
-# Test case for the Zlib::GzipWriter class.
-########################################################################
-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) }
-    assert_nothing_raised{ @writer = Zlib::GzipWriter.new(@handle, nil) }
-    assert_nothing_raised{ @writer = Zlib::GzipWriter.new(@handle, nil, nil) }
-  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(Integer, @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

data/test/test_zlib_inflate.rb

@@ -1,55 +0,0 @@
-########################################################################
-# test_zlib_inflate.rb
-#
-# Test case for the Zlib::Inflate class.
-########################################################################
-require 'pr/zlib'
-require 'test-unit'
-
-class TC_Zlib_Inflate < Test::Unit::TestCase
-   def self.startup
-   end
-
-   def setup
-      @inflate = Zlib::Inflate.new
-   end
-
-   def test_inflate_run_singleton_basic
-      assert_respond_to(Zlib::Inflate, :inflate_run)
-   end
-
-   def test_inflate_singleton_basic
-      assert_respond_to(Zlib::Inflate, :inflate)
-   end
-
-   #def test_initialize_copy_basic
-      #assert_respond_to(@inflate, :initialize_copy)
-   #end
-
-   def test_inflate_basic
-      assert_respond_to(@inflate, :inflate)
-   end
-
-   def test_append_basic
-      assert_respond_to(@inflate, :<<)
-   end
-
-   def test_sync_basic
-      assert_respond_to(@inflate, :sync)
-   end
-
-   def test_is_sync_point_basic
-      assert_respond_to(@inflate, :sync_point?)
-   end
-
-   def test_set_dictionary_basic
-      assert_respond_to(@inflate, :set_dictionary)
-   end
-
-   def teardown
-      @inflate = nil
-   end
-
-   def self.shutdown
-   end
-end

data/test/test_zlib_zstream.rb

@@ -1,146 +0,0 @@
-require 'test-unit'
-require 'pr/zlib'
-
-class TC_Zlib_Zstream < Test::Unit::TestCase
-   def self.startup
-   end
-
-   def setup
-      @zstream = Zlib::ZStream.new
-      @zfunc   = Zlib::ZStreamFuncs.new
-      @zstream.zstream_init(@zfunc)
-      @src = Array.new(128, 0.chr)
-   end
-
-   def test_flags
-      assert_respond_to(@zstream, :flags)
-      assert_respond_to(@zstream, :flags=)
-   end
-
-   def test_buf
-      assert_respond_to(@zstream, :buf)
-      assert_respond_to(@zstream, :buf=)
-   end
-
-   def test_input
-      assert_respond_to(@zstream, :input)
-      assert_respond_to(@zstream, :input=)
-   end
-
-   def test_stream
-      assert_respond_to(@zstream, :stream)
-      assert_respond_to(@zstream, :stream=)
-   end
-
-   def test_func
-      assert_respond_to(@zstream, :func)
-      assert_respond_to(@zstream, :func=)
-   end
-
-   def test_raise_zlib_error_basic
-      assert_respond_to(@zstream, :raise_zlib_error)
-   end
-
-   def test_raise_zlib_error_stream_end
-      assert_raise(Zlib::StreamEnd){ @zstream.raise_zlib_error(Z_STREAM_END, nil) }
-      assert_raise_message('stream end'){ @zstream.raise_zlib_error(Z_STREAM_END, nil) }
-   end
-
-   def test_raise_zlib_error_need_dict
-      assert_raise(Zlib::NeedDict){ @zstream.raise_zlib_error(Z_NEED_DICT, nil) }
-      assert_raise_message('need dictionary'){ @zstream.raise_zlib_error(Z_NEED_DICT, nil) }
-   end
-
-   def test_raise_zlib_error_stream_error
-      assert_raise(Zlib::StreamError){ @zstream.raise_zlib_error(Z_STREAM_ERROR, nil) }
-      assert_raise_message('stream error'){ @zstream.raise_zlib_error(Z_STREAM_ERROR, nil) }
-   end
-
-   def test_raise_zlib_error_data_error
-      assert_raise(Zlib::DataError){ @zstream.raise_zlib_error(Z_DATA_ERROR, nil) }
-      assert_raise_message('data error'){ @zstream.raise_zlib_error(Z_DATA_ERROR, nil) }
-   end
-
-   def test_raise_zlib_error_buf_error
-      assert_raise(Zlib::BufError){ @zstream.raise_zlib_error(Z_BUF_ERROR, nil) }
-      assert_raise_message('buffer error'){ @zstream.raise_zlib_error(Z_BUF_ERROR, nil) }
-   end
-
-   def test_raise_zlib_error_version_error
-      assert_raise(Zlib::VersionError){ @zstream.raise_zlib_error(Z_VERSION_ERROR, nil) }
-      assert_raise_message('incompatible version'){ @zstream.raise_zlib_error(Z_VERSION_ERROR, nil) }
-   end
-
-   def test_raise_zlib_error_mem_error
-      assert_raise(Zlib::MemError){ @zstream.raise_zlib_error(Z_MEM_ERROR, nil) }
-      assert_raise_message('insufficient memory'){ @zstream.raise_zlib_error(Z_MEM_ERROR, nil) }
-   end
-
-   def test_raise_zlib_error_errno
-      assert_raise(SystemCallError){ @zstream.raise_zlib_error(Z_ERRNO, nil) }
-      assert_raise_message('unknown error - file error'){ @zstream.raise_zlib_error(Z_ERRNO, nil) }
-   end
-
-   def test_raise_zlib_error_unknown
-      #notify('I think there might be a problem here - need to investigate')
-      assert_raise(Zlib::Error){ @zstream.raise_zlib_error(999, nil) }
-      assert_raise_message('unknown error - file error'){ @zstream.raise_zlib_error(Z_ERRNO, nil) }
-   end
-
-   def test_zstream_expand_buffer_basic
-      assert_respond_to(@zstream, :zstream_expand_buffer)
-      assert_nothing_raised{ @zstream.zstream_expand_buffer }
-   end
-
-   # @zstream.buf set after call
-   def test_zstream_expand_buffer
-      assert_nil(@zstream.buf)
-      assert_nil(@zstream.zstream_expand_buffer)
-      assert_kind_of(Bytef_str, @zstream.buf)
-   end
-
-   def test_zstream_expand_buffer_expected_errors
-      #notify("Modify zstream_expand_buffer method to explicitly handle a nil @stream")
-      assert_raise(ArgumentError){ @zstream.zstream_expand_buffer(1) }
-   end
-
-   def test_zstream_append_buffer_basic
-      assert_respond_to(@zstream, :zstream_append_buffer)
-      assert_nothing_raised{ @zstream.zstream_append_buffer(@src, @src.length) }
-   end
-
-   # @zstream.buf set after call
-   def test_zstream_append_buffer
-      assert_nil(@zstream.buf)
-      assert_nil(@zstream.zstream_append_buffer(@src, @src.length))
-      assert_kind_of(Bytef_arr, @zstream.buf)
-   end
-
-   def test_zstream_append_buffer_expected_errors
-      assert_raise(ArgumentError){ @zstream.zstream_append_buffer }
-   end
-
-   def test_zstream_detach_buffer_basic
-      assert_respond_to(@zstream, :zstream_detach_buffer)
-      assert_nothing_raised{ @zstream.zstream_detach_buffer }
-   end
-
-   def test_zstream_detach_buffer
-      assert_kind_of(String, @zstream.zstream_detach_buffer)
-      assert_not_nil(@zstream.buf)
-   end
-
-   def test_zstream_shift_buffer_basic
-      @zstream.buf = Bytef.new(0.chr * Zlib::ZSTREAM_INITIAL_BUFSIZE)
-      assert_respond_to(@zstream, :zstream_shift_buffer)
-      assert_nothing_raised{ @zstream.zstream_shift_buffer(1) }
-   end
-
-   def teardown
-      @zstream = nil
-      @src = nil
-   end
-
-   def self.shutdown
-   end
-end