pr-zlib 1.0.5 → 1.1.0

data/spec/zlib/gzip_writer_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+########################################################################
+# gzip_writer_spec.rb
+#
+# Spec for the Zlib::GzipWriter class.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib::GzipWriter do
+  before(:all) do
+    @gz_file = 'gzip_writer_test.gz'
+  end
+
+  after(:all) do
+    File.delete(@gz_file) if File.exist?(@gz_file)
+  end
+
+  let(:handle) { File.new(@gz_file, 'w') }
+  let(:writer) { described_class.new(handle) }
+  let(:time) { Time.now }
+
+  after do
+    handle.close if handle && !handle.closed?
+  end
+
+  describe 'constructor' do
+    it 'can be created with just a handle' do
+      expect { described_class.new(handle) }.not_to raise_error
+    end
+
+    it 'can be created with handle and level' do
+      expect { described_class.new(handle, nil) }.not_to raise_error
+    end
+
+    it 'can be created with handle, level, and strategy' do
+      expect { described_class.new(handle, nil, nil) }.not_to raise_error
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#level' do
+    it 'responds to level' do
+      expect(writer).to respond_to(:level)
+    end
+
+    it 'returns the default compression level' do
+      expect(writer.level).to eq(Rbzlib::Z_DEFAULT_COMPRESSION)
+    end
+  end
+
+  describe '#mtime' do
+    it 'responds to mtime getter' do
+      expect(writer).to respond_to(:mtime)
+    end
+
+    it 'can get mtime without errors' do
+      expect { writer.mtime }.not_to raise_error
+    end
+
+    it 'returns a Time object' do
+      expect(writer.mtime).to be_a(Time)
+    end
+
+    it 'starts at Time.at(0)' do
+      expect(writer.mtime).to eq(Time.at(0))
+    end
+
+    it 'responds to mtime setter' do
+      expect(writer).to respond_to(:mtime=)
+    end
+
+    it 'can set mtime without errors' do
+      expect { writer.mtime = time }.not_to raise_error
+    end
+
+    it 'returns the set value' do
+      expect(writer.mtime = time).to eq(time)
+    end
+  end
+
+  describe '#orig_name' do
+    it 'responds to orig_name getter' do
+      expect(writer).to respond_to(:orig_name)
+    end
+
+    it 'can get orig_name without errors' do
+      expect { writer.orig_name }.not_to raise_error
+    end
+
+    it 'returns nil initially' do
+      expect(writer.orig_name).to be_nil
+    end
+
+    it 'responds to orig_name setter' do
+      expect(writer).to respond_to(:orig_name=)
+    end
+
+    it 'can set orig_name without errors' do
+      expect { writer.orig_name = 'test' }.not_to raise_error
+    end
+
+    it 'returns and stores the set value' do
+      expect(writer.orig_name = 'test').to eq('test')
+      expect(writer.orig_name).to eq('test')
+    end
+  end
+
+  describe '#comment' do
+    it 'responds to comment getter' do
+      expect(writer).to respond_to(:comment)
+    end
+
+    it 'can get comment without errors' do
+      expect { writer.comment }.not_to raise_error
+    end
+
+    it 'returns nil initially' do
+      expect(writer.comment).to be_nil
+    end
+
+    it 'responds to comment setter' do
+      expect(writer).to respond_to(:comment=)
+    end
+
+    it 'can set comment without errors' do
+      expect { writer.comment = 'test' }.not_to raise_error
+    end
+
+    it 'returns and stores the set value' do
+      expect(writer.comment = 'test').to eq('test')
+      expect(writer.comment).to eq('test')
+    end
+  end
+
+  describe '#pos' do
+    it 'responds to pos' do
+      expect(writer).to respond_to(:pos)
+    end
+
+    it 'can get pos without errors' do
+      expect { writer.pos }.not_to raise_error
+    end
+
+    it 'returns an integer' do
+      expect(writer.pos).to be_a(Integer)
+    end
+
+    it 'starts at 0' do
+      expect(writer.pos).to eq(0)
+    end
+
+    it 'updates after writing' do
+      expect { writer.write('test') }.not_to raise_error
+      expect(writer.pos).to eq(4)
+    end
+
+    it 'has tell as an alias' do
+      expect(writer.method(:pos)).to eq(writer.method(:tell))
+    end
+  end
+
+  describe '.open' do
+    it 'responds to open class method' do
+      expect(described_class).to respond_to(:open)
+    end
+
+    it 'can open with block without errors' do
+      expect { described_class.open(@gz_file) {} }.not_to raise_error
+    end
+  end
+
+  describe '#flush' do
+    it 'responds to flush' do
+      expect(writer).to respond_to(:flush)
+    end
+
+    it 'can flush without errors' do
+      expect { writer.flush }.not_to raise_error
+    end
+
+    it 'returns self' do
+      expect(writer.flush).to eq(writer)
+    end
+  end
+
+  describe '#write' do
+    it 'responds to write' do
+      expect(writer).to respond_to(:write)
+    end
+
+    it 'can write without errors' do
+      expect { writer.write('test') }.not_to raise_error
+    end
+
+    it 'returns number of bytes written for string' do
+      expect(writer.write('test')).to eq(4)
+    end
+
+    it 'returns number of bytes written for number' do
+      expect(writer.write(999)).to eq(3)
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { writer.write }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#putc' do
+    it 'responds to putc' do
+      expect(writer).to respond_to(:putc)
+    end
+
+    it 'can putc without errors' do
+      expect { writer.putc(97) }.not_to raise_error
+    end
+
+    it 'returns the character code' do
+      expect(writer.putc(97)).to eq(97)
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { writer.putc }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#<<' do
+    it 'responds to <<' do
+      expect(writer).to respond_to(:<<)
+    end
+
+    it 'can append without errors' do
+      expect { writer << 'test' }.not_to raise_error
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { writer.send(:<<) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#printf' do
+    it 'responds to printf' do
+      expect(writer).to respond_to(:printf)
+    end
+
+    it 'can printf without errors' do
+      expect { writer.printf('%s', 'test') }.not_to raise_error
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { writer.printf }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#puts' do
+    it 'responds to puts' do
+      expect(writer).to respond_to(:puts)
+    end
+
+    it 'can puts without errors' do
+      expect { writer.puts('test') }.not_to raise_error
+    end
+
+    it 'raises ArgumentError with no arguments' do
+      expect { writer.puts }.to raise_error(ArgumentError)
+    end
+
+    it 'raises ArgumentError with multiple arguments' do
+      expect { writer.puts('test1', 'test2') }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/zlib/inflate_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+########################################################################
+# inflate_spec.rb
+#
+# Spec for the Zlib::Inflate class.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib::Inflate do
+  let(:inflate) { described_class.new }
+
+  describe 'class methods' do
+    it 'responds to inflate_run' do
+      expect(described_class).to respond_to(:inflate_run)
+    end
+
+    it 'responds to inflate' do
+      expect(described_class).to respond_to(:inflate)
+    end
+  end
+
+  describe 'instance methods' do
+    it 'responds to inflate' do
+      expect(inflate).to respond_to(:inflate)
+    end
+
+    it 'responds to <<' do
+      expect(inflate).to respond_to(:<<)
+    end
+
+    it 'responds to sync' do
+      expect(inflate).to respond_to(:sync)
+    end
+
+    it 'responds to sync_point?' do
+      expect(inflate).to respond_to(:sync_point?)
+    end
+
+    it 'responds to set_dictionary' do
+      expect(inflate).to respond_to(:set_dictionary)
+    end
+  end
+end

data/spec/zlib/zstream_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+########################################################################
+# zstream_spec.rb
+#
+# Spec for the Zlib::ZStream class.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib::ZStream do
+  let(:zstream) { described_class.new }
+  let(:zfunc) { Zlib::ZStreamFuncs.new }
+  let(:src) { Array.new(128, 0.chr) }
+
+  before do
+    zstream.zstream_init(zfunc)
+  end
+
+  describe 'accessors' do
+    it 'has flags accessor' do
+      expect(zstream).to respond_to(:flags)
+      expect(zstream).to respond_to(:flags=)
+    end
+
+    it 'has buf accessor' do
+      expect(zstream).to respond_to(:buf)
+      expect(zstream).to respond_to(:buf=)
+    end
+
+    it 'has input accessor' do
+      expect(zstream).to respond_to(:input)
+      expect(zstream).to respond_to(:input=)
+    end
+
+    it 'has stream accessor' do
+      expect(zstream).to respond_to(:stream)
+      expect(zstream).to respond_to(:stream=)
+    end
+
+    it 'has func accessor' do
+      expect(zstream).to respond_to(:func)
+      expect(zstream).to respond_to(:func=)
+    end
+  end
+
+  describe '#raise_zlib_error' do
+    it 'responds to raise_zlib_error' do
+      expect(zstream).to respond_to(:raise_zlib_error)
+    end
+
+    it 'raises StreamEnd for Z_STREAM_END' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_STREAM_END, nil) }.to raise_error(Zlib::StreamEnd, 'stream end')
+    end
+
+    it 'raises NeedDict for Z_NEED_DICT' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_NEED_DICT, nil) }.to raise_error(Zlib::NeedDict, 'need dictionary')
+    end
+
+    it 'raises StreamError for Z_STREAM_ERROR' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_STREAM_ERROR, nil) }.to raise_error(Zlib::StreamError, 'stream error')
+    end
+
+    it 'raises DataError for Z_DATA_ERROR' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_DATA_ERROR, nil) }.to raise_error(Zlib::DataError, 'data error')
+    end
+
+    it 'raises BufError for Z_BUF_ERROR' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_BUF_ERROR, nil) }.to raise_error(Zlib::BufError, 'buffer error')
+    end
+
+    it 'raises VersionError for Z_VERSION_ERROR' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_VERSION_ERROR, nil) }.to raise_error(Zlib::VersionError, 'incompatible version')
+    end
+
+    it 'raises MemError for Z_MEM_ERROR' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_MEM_ERROR, nil) }.to raise_error(Zlib::MemError, 'insufficient memory')
+    end
+
+    it 'raises SystemCallError for Z_ERRNO' do
+      expect { zstream.raise_zlib_error(Rbzlib::Z_ERRNO, nil) }.to raise_error(SystemCallError)
+    end
+
+    it 'raises Error for unknown error codes' do
+      expect { zstream.raise_zlib_error(999, nil) }.to raise_error(Zlib::Error)
+    end
+  end
+
+  describe '#zstream_expand_buffer' do
+    it 'responds to zstream_expand_buffer' do
+      expect(zstream).to respond_to(:zstream_expand_buffer)
+    end
+
+    it 'expands buffer without errors' do
+      expect { zstream.zstream_expand_buffer }.not_to raise_error
+    end
+
+    it 'sets buf after call' do
+      expect(zstream.buf).to be_nil
+      zstream.zstream_expand_buffer
+      expect(zstream.buf).to be_a(Bytef_str)
+    end
+
+    it 'raises ArgumentError with wrong number of arguments' do
+      expect { zstream.zstream_expand_buffer(1) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#zstream_append_buffer' do
+    it 'responds to zstream_append_buffer' do
+      expect(zstream).to respond_to(:zstream_append_buffer)
+    end
+
+    it 'appends buffer without errors' do
+      expect { zstream.zstream_append_buffer(src, src.length) }.not_to raise_error
+    end
+
+    it 'sets buf after call' do
+      expect(zstream.buf).to be_nil
+      zstream.zstream_append_buffer(src, src.length)
+      expect(zstream.buf).to be_a(Bytef_arr)
+    end
+
+    it 'raises ArgumentError without arguments' do
+      expect { zstream.zstream_append_buffer }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#zstream_detach_buffer' do
+    it 'responds to zstream_detach_buffer' do
+      expect(zstream).to respond_to(:zstream_detach_buffer)
+    end
+
+    it 'detaches buffer without errors' do
+      expect { zstream.zstream_detach_buffer }.not_to raise_error
+    end
+
+    it 'returns a string' do
+      expect(zstream.zstream_detach_buffer).to be_a(String)
+      expect(zstream.buf).not_to be_nil
+    end
+  end
+
+  describe '#zstream_shift_buffer' do
+    before do
+      zstream.buf = Bytef.new(0.chr * Zlib::ZSTREAM_INITIAL_BUFSIZE)
+    end
+
+    it 'responds to zstream_shift_buffer' do
+      expect(zstream).to respond_to(:zstream_shift_buffer)
+    end
+
+    it 'shifts buffer without errors' do
+      expect { zstream.zstream_shift_buffer(1) }.not_to raise_error
+    end
+  end
+end

data/spec/zlib_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+########################################################################
+# zlib_spec.rb
+#
+# Spec for the Zlib module.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib do
+  let(:zstream_funcs) { described_class::ZStreamFuncs.new }
+
+  describe 'version constants' do
+    it 'has the correct Ruby zlib version' do
+      expect(described_class::VERSION).to eq('0.6.0')
+      expect(described_class::RUBY_ZLIB_VERSION).to eq('0.6.0')
+    end
+
+    it 'has the correct zlib version' do
+      expect(described_class::ZLIB_VERSION).to eq('1.2.3')
+      expect(described_class::PR_ZLIB_VERSION).to eq('1.1.0')
+    end
+  end
+
+  describe 'data type constants' do
+    it 'includes data type constants' do
+      expect(described_class::BINARY).not_to be_nil
+      expect(described_class::ASCII).not_to be_nil
+      expect(described_class::UNKNOWN).not_to be_nil
+    end
+  end
+
+  describe 'compression constants' do
+    it 'includes compression level constants' do
+      expect(described_class::NO_COMPRESSION).not_to be_nil
+      expect(described_class::BEST_SPEED).not_to be_nil
+      expect(described_class::BEST_COMPRESSION).not_to be_nil
+      expect(described_class::DEFAULT_COMPRESSION).not_to be_nil
+    end
+  end
+
+  describe 'encoding constants' do
+    it 'includes encoding strategy constants' do
+      expect(described_class::FILTERED).not_to be_nil
+      expect(described_class::HUFFMAN_ONLY).not_to be_nil
+      expect(described_class::DEFAULT_STRATEGY).not_to be_nil
+      expect(described_class::MAX_WBITS).not_to be_nil
+      expect(described_class::DEF_MEM_LEVEL).not_to be_nil
+      expect(described_class::MAX_MEM_LEVEL).not_to be_nil
+      expect(described_class::NO_FLUSH).not_to be_nil
+      expect(described_class::SYNC_FLUSH).not_to be_nil
+      expect(described_class::FULL_FLUSH).not_to be_nil
+      expect(described_class::FINISH).not_to be_nil
+    end
+  end
+
+  describe 'OS constants' do
+    it 'has the correct OS constant values' do
+      expect(described_class::OS_MSDOS).to eq(0x00)
+      expect(described_class::OS_AMIGA).to eq(0x01)
+      expect(described_class::OS_VMS).to eq(0x02)
+      expect(described_class::OS_UNIX).to eq(0x03)
+      expect(described_class::OS_ATARI).to eq(0x05)
+      expect(described_class::OS_OS2).to eq(0x06)
+      expect(described_class::OS_MACOS).to eq(0x07)
+      expect(described_class::OS_TOPS20).to eq(0x0a)
+      expect(described_class::OS_WIN32).to eq(0x0b)
+    end
+  end
+
+  describe 'zstream flag constants' do
+    it 'has the correct flag values' do
+      expect(described_class::ZSTREAM_FLAG_READY).to eq(0x1)
+      expect(described_class::ZSTREAM_FLAG_IN_STREAM).to eq(0x2)
+      expect(described_class::ZSTREAM_FLAG_FINISHED).to eq(0x4)
+      expect(described_class::ZSTREAM_FLAG_CLOSING).to eq(0x8)
+      expect(described_class::ZSTREAM_FLAG_UNUSED).to eq(0x10)
+    end
+  end
+
+  describe 'zstream buffer constants' do
+    it 'has the correct buffer size values' do
+      expect(described_class::ZSTREAM_INITIAL_BUFSIZE).to eq(1024)
+      expect(described_class::ZSTREAM_AVAIL_OUT_STEP_MAX).to eq(16384)
+      expect(described_class::ZSTREAM_AVAIL_OUT_STEP_MIN).to eq(2048)
+    end
+  end
+
+  describe '.zlib_version' do
+    it 'responds to zlib_version' do
+      expect(described_class).to respond_to(:zlib_version)
+    end
+  end
+
+  describe '.adler32' do
+    it 'responds to adler32' do
+      expect(described_class).to respond_to(:adler32)
+    end
+
+    it 'can be called without arguments' do
+      expect { described_class.adler32 }.not_to raise_error
+    end
+
+    it 'returns correct values' do
+      expect(described_class.adler32).to eq(1)
+      expect(described_class.adler32('test')).to eq(73204161)
+      expect(described_class.adler32(nil, 3)).to eq(1)
+      expect(described_class.adler32('test', 3)).to eq(73728451)
+    end
+
+    it 'raises RangeError for values too large' do
+      expect { described_class.adler32('test', 2**128) }.to raise_error(RangeError)
+    end
+  end
+
+  describe '.crc32' do
+    it 'responds to crc32' do
+      expect(described_class).to respond_to(:crc32)
+    end
+
+    it 'can be called without arguments' do
+      expect { described_class.crc32 }.not_to raise_error
+    end
+
+    it 'returns correct values' do
+      expect(described_class.crc32).to eq(0)
+      expect(described_class.crc32('test')).to eq(3632233996)
+      expect(described_class.crc32(nil, 3)).to eq(0)
+      expect(described_class.crc32('test', 3)).to eq(3402289634)
+    end
+
+    it 'raises RangeError for values too large' do
+      expect { described_class.crc32('test', 2**128) }.to raise_error(RangeError)
+    end
+  end
+
+  describe '.crc_table' do
+    it 'responds to crc_table' do
+      expect(described_class).to respond_to(:crc_table)
+    end
+
+    it 'returns an array' do
+      expect { described_class.crc_table }.not_to raise_error
+      expect(described_class.crc_table).to be_a(Array)
+    end
+  end
+
+  describe 'ZStreamFuncs struct' do
+    it 'is a ZStreamFuncs instance' do
+      expect(zstream_funcs).to be_a(described_class::ZStreamFuncs)
+    end
+
+    it 'responds to struct methods' do
+      expect(zstream_funcs).to respond_to(:reset)
+      expect(zstream_funcs).to respond_to(:end)
+      expect(zstream_funcs).to respond_to(:run)
+    end
+  end
+
+  describe 'error classes' do
+    it 'defines Error class' do
+      expect(described_class::Error).not_to be_nil
+      expect(described_class::Error.new).to be_a(StandardError)
+    end
+
+    it 'defines StreamEnd class' do
+      expect(described_class::StreamEnd).not_to be_nil
+      expect(described_class::StreamEnd.new).to be_a(described_class::Error)
+    end
+
+    it 'defines NeedDict class' do
+      expect(described_class::NeedDict.new).to be_a(described_class::Error)
+    end
+
+    it 'defines DataError class' do
+      expect(described_class::DataError.new).to be_a(described_class::Error)
+    end
+
+    it 'defines StreamError class' do
+      expect(described_class::StreamError.new).to be_a(described_class::Error)
+    end
+
+    it 'defines MemError class' do
+      expect(described_class::MemError.new).to be_a(described_class::Error)
+    end
+
+    it 'defines BufError class' do
+      expect(described_class::BufError.new).to be_a(described_class::Error)
+    end
+
+    it 'defines VersionError class' do
+      expect(described_class::VersionError.new).to be_a(described_class::Error)
+    end
+  end
+end