pr-zlib 1.0.0

data/pr-zlib.gemspec

@@ -0,0 +1,28 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+   gem.name              = 'pr-zlib'
+   gem.version           = '1.0.0'
+   gem.authors           = ['Park Heesob', 'Daniel Berger']
+   gem.email             = 'phasis@gmail.com'
+   gem.homepage          = 'http://www.rubyforge.org/projects/pure'
+   gem.rubyforge_project = 'pure'
+   gem.platform          = Gem::Platform::RUBY
+   gem.summary           = 'Pure Ruby version of the zlib library'
+   gem.test_files        = Dir['test/*.rb']
+   gem.has_rdoc          = true
+   gem.files             = Dir["**/*"].reject{ |f| f.include?('SVN') }
+   gem.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+   
+   gem.add_dependency('test-unit', '>= 2.0.2')
+   
+   gem.description = <<-EOF
+      The pr-zlib library is a pure Ruby implementation of both the zlib C
+      library, and the Ruby zlib interface that ships as part of the standard
+      library.
+   EOF
+end
+
+if $0 == __FILE__
+   Gem::Builder.new(spec).build
+end

data/test/test_rbzlib.rb

@@ -0,0 +1,136 @@
+########################################################################
+# test_rbzlib.rb
+#
+# Test case for the Rbzlib module.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/rbzlib'
+require 'test/unit'
+
+class TC_Rbzlib < Test::Unit::TestCase
+   include Rbzlib
+
+   def setup
+      @fixnum = 7
+      @buffer = 0.chr * 16
+   end
+
+   def test_version
+      assert_equal('1.2.3', ZLIB_VERSION)
+   end
+
+   def test_fixnum_ord
+      assert_respond_to(7, :ord)
+      assert_equal(7, 7.ord)
+   end
+
+   def test_misc_constants
+      assert_equal(9, MAX_MEM_LEVEL)
+      assert_equal(8, DEF_MEM_LEVEL)
+      assert_equal(15, MAX_WBITS)
+      assert_equal(MAX_WBITS, DEF_WBITS)
+      assert_equal(0, STORED_BLOCK)
+      assert_equal(1, STATIC_TREES)
+      assert_equal(2, DYN_TREES)
+      assert_equal(3, MIN_MATCH)
+      assert_equal(258, MAX_MATCH)
+      assert_equal(0x20, PRESET_DICT)
+      assert_equal(65521, BASE)
+      assert_equal(5552, NMAX)
+      assert_equal(0, OS_CODE)
+      assert_equal(1, SEEK_CUR)
+      assert_equal(2, SEEK_END)
+   end
+
+   def test_sync_contants
+      assert_equal(0, Z_NO_FLUSH)
+      assert_equal(1, Z_PARTIAL_FLUSH)
+      assert_equal(2, Z_SYNC_FLUSH)
+      assert_equal(3, Z_FULL_FLUSH)
+      assert_equal(4, Z_FINISH)
+      assert_equal(5, Z_BLOCK)
+   end
+
+   def test_stream_constants
+      assert_equal(0, Z_OK)
+      assert_equal(1, Z_STREAM_END)
+      assert_equal(2, Z_NEED_DICT)
+      assert_equal(-1, Z_ERRNO)
+      assert_equal(-1, Z_EOF)
+      assert_equal(-2, Z_STREAM_ERROR)
+      assert_equal(-3, Z_DATA_ERROR)
+      assert_equal(-4, Z_MEM_ERROR)
+      assert_equal(-5, Z_BUF_ERROR)
+      assert_equal(-6, Z_VERSION_ERROR)
+      assert_equal(16384, Z_BUFSIZE)
+   end
+
+   def test_compression_constants
+      assert_equal(0, Z_NO_COMPRESSION)
+      assert_equal(1, Z_BEST_SPEED)
+      assert_equal(9, Z_BEST_COMPRESSION)
+      assert_equal(-1, Z_DEFAULT_COMPRESSION)
+      assert_equal(8, Z_DEFLATED)
+   end
+
+   def test_encoding_constants
+      assert_equal(1, Z_FILTERED)
+      assert_equal(2, Z_HUFFMAN_ONLY)
+      assert_equal(3, Z_RLE)
+      assert_equal(4, Z_FIXED)
+      assert_equal(0, Z_DEFAULT_STRATEGY)
+   end
+
+   def test_crc_constants
+      assert_equal(0x01, ASCII_FLAG)
+      assert_equal(0x02, HEAD_CRC)
+      assert_equal(0x04, EXTRA_FIELD)
+      assert_equal(0x08, ORIG_NAME)
+      assert_equal(0x10, COMMENT_)
+      assert_equal(0xE0, RESERVED)
+   end
+
+   def test_zError
+      assert_respond_to(self, :zError)
+      assert_equal('stream end', self.zError(Z_STREAM_END))
+   end
+
+   def test_zlibVersion
+      assert_respond_to(self, :zlibVersion)
+      assert_equal(ZLIB_VERSION, self.zlibVersion)
+   end
+
+   def test_z_error
+      assert_respond_to(self, :z_error)
+      assert_raise(RuntimeError){ self.z_error('hello') }
+   end
+
+   def test_adler32
+      assert_respond_to(Rbzlib, :adler32)
+      assert_equal(1, Rbzlib.adler32(32, nil))
+      assert_equal(0, Rbzlib.adler32(0, @buffer))
+      assert_equal(1048577, Rbzlib.adler32(1, @buffer))
+      assert_equal(10485770, Rbzlib.adler32(10, @buffer))
+      assert_equal(33554464, Rbzlib.adler32(32, @buffer))
+   end
+
+   def test_adler32_expected_errors
+      assert_raise(ArgumentError){ Rbzlib.adler32 }
+      assert_raise(ArgumentError){ Rbzlib.adler32('test') }
+   end
+
+   def test_get_crc_table
+      assert_respond_to(Rbzlib, :get_crc_table)
+   end
+
+   def test_gz_open
+      assert_respond_to(Rbzlib, :gz_open)
+   end
+
+   def teardown
+      @fixnum = 0
+      @buffer = nil
+   end
+end

data/test/test_rbzlib_bytef.rb

@@ -0,0 +1,79 @@
+########################################################################
+# test_rbzlib_bytef.rb
+#
+# Test case for the Zlib::Bytef class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/rbzlib'
+require 'test/unit'
+
+class TC_Rbzlib_Bytef < Test::Unit::TestCase
+   def setup
+      @buffer = 0.chr * 32 
+      @bytef  = Rbzlib::Bytef.new(@buffer)
+   end
+
+   def test_buffer_get
+      assert_respond_to(@bytef, :buffer)
+      assert_equal(@buffer, @bytef.buffer)
+   end
+
+   def test_buffer_set
+      assert_respond_to(@bytef, :buffer=)
+      assert_nothing_raised{ @bytef.buffer = 0.chr * 8 }
+      assert_equal(0.chr * 8, @bytef.buffer)
+   end
+
+   def test_length
+      assert_respond_to(@bytef, :length)
+      assert_equal(32, @bytef.length)
+   end
+
+   def test_increment
+      assert_respond_to(@bytef, :+)
+      assert_nothing_raised{ @bytef + 1 }
+      assert_equal(1, @bytef.offset)
+   end
+
+   def test_decrement
+      assert_respond_to(@bytef, :-)
+      assert_nothing_raised{ @bytef - 1 }
+      assert_equal(-1, @bytef.offset)
+   end
+
+   def test_aref
+      assert_respond_to(@bytef, :[])
+      assert_nothing_raised{ @bytef[1] }
+      assert_equal(0, @bytef[1])
+   end
+
+   def test_aset
+      assert_respond_to(@bytef, :[]=)
+      assert_nothing_raised{ @bytef[1] = 1.chr }
+      assert_equal(1, @bytef[1])
+   end
+
+   def test_get
+      assert_respond_to(@bytef, :get)
+      assert_nothing_raised{ @bytef.get }
+      assert_equal(0, @bytef.get)
+   end
+
+   def test_set
+      assert_respond_to(@bytef, :set)
+      assert_nothing_raised{ @bytef.set('a') }
+      assert_equal(97, @bytef.get)
+   end
+
+   def test_current
+      assert_respond_to(@bytef, :current)
+      assert_equal(@buffer, @bytef.current)
+   end
+
+   def teardown
+      @bytef  = nil
+      @buffer = nil
+   end
+end

data/test/test_rbzlib_posf.rb

@@ -0,0 +1,59 @@
+########################################################################
+# test_rbzlib_posf.rb
+#
+# Test case for the Zlib::Posf class.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'pr/rbzlib'
+require 'test/unit'
+
+class TC_Rbzlib_Posf < Test::Unit::TestCase
+   def setup
+      @buffer = 0.chr * 32
+      @posf   = Rbzlib::Posf.new(@buffer)
+   end
+
+   def test_increment
+      assert_respond_to(@posf, :+)
+      assert_nothing_raised{ @posf + 4 }
+      assert_equal(8, @posf.offset)
+   end
+
+   def test_decrement
+      assert_respond_to(@posf, :-)
+      assert_nothing_raised{ @posf - 4 }
+      assert_equal(-8, @posf.offset)
+   end
+
+   def test_aref
+      assert_respond_to(@posf, :[])
+      assert_nothing_raised{ @posf[2] }
+      assert_equal(0, @posf[2])
+   end
+
+   def test_aset
+      assert_respond_to(@posf, :[]=)
+      assert_nothing_raised{ @posf[2] = 7 }
+      assert_equal(7, @posf[2])
+      assert_equal("\a\000", @posf.buffer[4,2])
+   end
+
+   def test_get
+      assert_respond_to(@posf, :get)
+      assert_nothing_raised{ @posf.get }
+      assert_equal(0, @posf.get)
+   end
+
+   def test_set
+      assert_respond_to(@posf, :set)
+      assert_nothing_raised{ @posf.set(4) }
+      assert_equal("\004\000", @posf.buffer[0,2])
+   end
+
+   def teardown
+      @posf   = nil
+      @buffer = nil
+   end
+end

data/test/test_zlib.rb

@@ -0,0 +1,163 @@
+########################################################################
+# test_zlib.rb
+#
+# Test case for the Zlib module.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'pr/zlib'
+
+class TC_Zlib < Test::Unit::TestCase
+   def self.startup
+   end
+
+   def setup
+      @zstream_funcs = Zlib::ZStreamFuncs.new
+   end
+
+   def test_ruby_zlib_version
+      assert_equal('0.6.0', Zlib::VERSION)
+      assert_equal('0.6.0', Zlib::RUBY_ZLIB_VERSION)
+   end
+
+   def test_zlib_version
+      assert_equal('1.2.3', Zlib::ZLIB_VERSION)
+      assert_equal('1.0.0', Zlib::PR_ZLIB_VERSION)
+   end
+
+   def test_zlib_included_constants
+      assert_not_nil(Zlib::BINARY)
+      assert_not_nil(Zlib::ASCII)
+      assert_not_nil(Zlib::UNKNOWN)
+   end
+
+   def test_zlib_included_compression_constants
+      assert_not_nil(Zlib::NO_COMPRESSION)
+      assert_not_nil(Zlib::BEST_SPEED)
+      assert_not_nil(Zlib::BEST_COMPRESSION)
+      assert_not_nil(Zlib::DEFAULT_COMPRESSION)
+   end
+
+   def test_zlib_included_encoding_constants
+      assert_not_nil(Zlib::FILTERED)
+      assert_not_nil(Zlib::HUFFMAN_ONLY)
+      assert_not_nil(Zlib::DEFAULT_STRATEGY)
+      assert_not_nil(Zlib::MAX_WBITS)
+      assert_not_nil(Zlib::DEF_MEM_LEVEL)
+      assert_not_nil(Zlib::MAX_MEM_LEVEL)
+      assert_not_nil(Zlib::NO_FLUSH)
+      assert_not_nil(Zlib::SYNC_FLUSH)
+      assert_not_nil(Zlib::FULL_FLUSH)
+      assert_not_nil(Zlib::FINISH)
+   end
+
+   def test_zlib_os_constants
+      assert_equal(0x00, Zlib::OS_MSDOS)
+      assert_equal(0x01, Zlib::OS_AMIGA)
+      assert_equal(0x02, Zlib::OS_VMS)
+      assert_equal(0x03, Zlib::OS_UNIX)
+      assert_equal(0x05, Zlib::OS_ATARI)
+      assert_equal(0x06, Zlib::OS_OS2)
+      assert_equal(0x07, Zlib::OS_MACOS)
+      assert_equal(0x0a, Zlib::OS_TOPS20)
+      assert_equal(0x0b, Zlib::OS_WIN32)
+   end
+
+   def test_zlib_zstream_flag_constants
+      assert_equal(0x1, Zlib::ZSTREAM_FLAG_READY)
+      assert_equal(0x2, Zlib::ZSTREAM_FLAG_IN_STREAM)
+      assert_equal(0x4, Zlib::ZSTREAM_FLAG_FINISHED)
+      assert_equal(0x8, Zlib::ZSTREAM_FLAG_CLOSING)
+      assert_equal(0x10, Zlib::ZSTREAM_FLAG_UNUSED)
+   end
+
+   def test_zlib_zstream_buffer_constants
+      assert_equal(1024, Zlib::ZSTREAM_INITIAL_BUFSIZE)
+      assert_equal(16384, Zlib::ZSTREAM_AVAIL_OUT_STEP_MAX)
+      assert_equal(2048, Zlib::ZSTREAM_AVAIL_OUT_STEP_MIN)
+   end
+
+   def test_zlib_version_module_function
+      assert_respond_to(Zlib, :zlib_version)
+   end
+
+   def test_adler32_module_function_basic
+      assert_respond_to(Zlib, :adler32)
+      assert_nothing_raised{ Zlib.adler32 }
+   end
+
+   def test_adler32_module_function
+      assert_equal(1, Zlib.adler32)
+      assert_equal(73204161, Zlib.adler32('test'))
+      assert_equal(1, Zlib.adler32(nil, 3))
+      assert_equal(73728451, Zlib.adler32('test', 3))
+   end
+
+   def test_crc32_module_function_basic
+      assert_respond_to(Zlib, :crc32)
+      assert_nothing_raised{ Zlib.crc32 }
+   end
+
+   def test_crc32_module_function
+      assert_equal(0, Zlib.crc32)
+      assert_equal(3632233996, Zlib.crc32('test'))
+      assert_equal(0, Zlib.crc32(nil, 3))
+      assert_equal(3402289634, Zlib.crc32('test', 3))
+   end
+
+   def test_crc_table_module_function_basic
+      assert_respond_to(Zlib, :crc_table)
+      assert_nothing_raised{ Zlib.crc_table }
+      assert_kind_of(Array, Zlib.crc_table)
+   end
+
+   def test_zstream_funcs_struct
+      assert_kind_of(Zlib::ZStreamFuncs, @zstream_funcs)
+      assert_respond_to(@zstream_funcs, :reset)
+      assert_respond_to(@zstream_funcs, :end)
+      assert_respond_to(@zstream_funcs, :run)
+   end
+
+   def test_error_class
+      assert_not_nil(Zlib::Error)
+      assert_kind_of(StandardError, Zlib::Error.new)
+   end
+
+   def test_stream_end_class
+      assert_not_nil(Zlib::StreamEnd)
+      assert_kind_of(Zlib::Error, Zlib::StreamEnd.new)
+   end
+
+   def test_need_dict_class
+      assert_kind_of(Zlib::Error, Zlib::NeedDict.new)
+   end
+
+   def test_data_error_class
+      assert_kind_of(Zlib::Error, Zlib::DataError.new)
+   end
+
+   def test_stream_error_class
+      assert_kind_of(Zlib::Error, Zlib::StreamError.new)
+   end
+
+   def test_mem_error_class
+      assert_kind_of(Zlib::Error, Zlib::MemError.new)
+   end
+
+   def test_buf_error_class
+      assert_kind_of(Zlib::Error, Zlib::BufError.new)
+   end
+
+   def test_version_error_class
+      assert_kind_of(Zlib::Error, Zlib::VersionError.new)
+   end
+
+   def teardown
+      @zstream_funcs = nil
+   end
+
+   def self.shutdown
+   end
+end