pr-zlib 1.0.5 → 1.1.0

data/spec/rbzlib_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+########################################################################
+# rbzlib_spec.rb
+#
+# Spec for the Rbzlib module.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Rbzlib do
+  include described_class
+
+  let(:fixnum) { 7 }
+  let(:buffer) { 0.chr * 16 }
+
+  describe 'version' do
+    it 'has the correct version' do
+      expect(ZLIB_VERSION).to eq('1.2.3')
+    end
+  end
+
+  describe 'Fixnum#ord' do
+    it 'responds to ord' do
+      expect(7).to respond_to(:ord)
+    end
+
+    it 'returns the number itself' do
+      expect(7.ord).to eq(7)
+    end
+  end
+
+  describe 'miscellaneous constants' do
+    it 'has the correct values' do
+      expect(MAX_MEM_LEVEL).to eq(9)
+      expect(DEF_MEM_LEVEL).to eq(8)
+      expect(MAX_WBITS).to eq(15)
+      expect(DEF_WBITS).to eq(MAX_WBITS)
+      expect(STORED_BLOCK).to eq(0)
+      expect(STATIC_TREES).to eq(1)
+      expect(DYN_TREES).to eq(2)
+      expect(MIN_MATCH).to eq(3)
+      expect(MAX_MATCH).to eq(258)
+      expect(PRESET_DICT).to eq(0x20)
+      expect(BASE).to eq(65521)
+      expect(NMAX).to eq(5552)
+      expect(OS_CODE).to eq(0)
+      expect(SEEK_CUR).to eq(1)
+      expect(SEEK_END).to eq(2)
+    end
+  end
+
+  describe 'sync constants' do
+    it 'has the correct values' do
+      expect(Z_NO_FLUSH).to eq(0)
+      expect(Z_PARTIAL_FLUSH).to eq(1)
+      expect(Z_SYNC_FLUSH).to eq(2)
+      expect(Z_FULL_FLUSH).to eq(3)
+      expect(Z_FINISH).to eq(4)
+      expect(Z_BLOCK).to eq(5)
+    end
+  end
+
+  describe 'stream constants' do
+    it 'has the correct values' do
+      expect(Z_OK).to eq(0)
+      expect(Z_STREAM_END).to eq(1)
+      expect(Z_NEED_DICT).to eq(2)
+      expect(Z_ERRNO).to eq(-1)
+      expect(Z_EOF).to eq(-1)
+      expect(Z_STREAM_ERROR).to eq(-2)
+      expect(Z_DATA_ERROR).to eq(-3)
+      expect(Z_MEM_ERROR).to eq(-4)
+      expect(Z_BUF_ERROR).to eq(-5)
+      expect(Z_VERSION_ERROR).to eq(-6)
+      expect(Z_BUFSIZE).to eq(16384)
+    end
+  end
+
+  describe 'compression constants' do
+    it 'has the correct values' do
+      expect(Z_NO_COMPRESSION).to eq(0)
+      expect(Z_BEST_SPEED).to eq(1)
+      expect(Z_BEST_COMPRESSION).to eq(9)
+      expect(Z_DEFAULT_COMPRESSION).to eq(-1)
+      expect(Z_DEFLATED).to eq(8)
+    end
+  end
+
+  describe 'encoding constants' do
+    it 'has the correct values' do
+      expect(Z_FILTERED).to eq(1)
+      expect(Z_HUFFMAN_ONLY).to eq(2)
+      expect(Z_RLE).to eq(3)
+      expect(Z_FIXED).to eq(4)
+      expect(Z_DEFAULT_STRATEGY).to eq(0)
+    end
+  end
+
+  describe 'CRC constants' do
+    it 'has the correct values' do
+      expect(ASCII_FLAG).to eq(0x01)
+      expect(HEAD_CRC).to eq(0x02)
+      expect(EXTRA_FIELD).to eq(0x04)
+      expect(ORIG_NAME).to eq(0x08)
+      expect(COMMENT_).to eq(0x10)
+      expect(RESERVED).to eq(0xE0)
+    end
+  end
+
+  describe '#zError' do
+    it 'responds to zError' do
+      expect(self).to respond_to(:zError)
+    end
+
+    it 'returns correct error messages' do
+      expect(zError(Z_STREAM_END)).to eq('stream end')
+    end
+  end
+
+  describe '#zlibVersion' do
+    it 'responds to zlibVersion' do
+      expect(self).to respond_to(:zlibVersion)
+    end
+
+    it 'returns the zlib version' do
+      expect(zlibVersion).to eq(ZLIB_VERSION)
+    end
+  end
+
+  describe '#z_error' do
+    it 'responds to z_error' do
+      expect(self).to respond_to(:z_error)
+    end
+
+    it 'raises RuntimeError' do
+      expect { z_error('hello') }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.adler32' do
+    it 'responds to adler32' do
+      expect(described_class).to respond_to(:adler32)
+    end
+
+    it 'returns correct values' do
+      expect(described_class.adler32(32, nil)).to eq(1)
+      expect(described_class.adler32(0, buffer)).to eq(0)
+      expect(described_class.adler32(1, buffer)).to eq(1048577)
+      expect(described_class.adler32(10, buffer)).to eq(10485770)
+      expect(described_class.adler32(32, buffer)).to eq(33554464)
+    end
+
+    it 'raises ArgumentError with wrong arguments' do
+      expect { described_class.adler32 }.to raise_error(ArgumentError)
+      expect { described_class.adler32('test') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '.get_crc_table' do
+    it 'responds to get_crc_table' do
+      expect(described_class).to respond_to(:get_crc_table)
+    end
+  end
+
+  describe '.gz_open' do
+    it 'responds to gz_open' do
+      expect(described_class).to respond_to(:gz_open)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'pr/zlib'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = "doc"
+  end
+
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+end

data/spec/zlib/deflate_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+########################################################################
+# deflate_spec.rb
+#
+# Spec for the Zlib::Deflate class.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib::Deflate do
+  let(:deflate) { described_class.new }
+
+  describe 'class methods' do
+    it 'responds to deflate_run' do
+      expect(described_class).to respond_to(:deflate_run)
+    end
+
+    it 'responds to deflate' do
+      expect(described_class).to respond_to(:deflate)
+    end
+  end
+
+  describe 'instance methods' do
+    it 'responds to deflate' do
+      expect(deflate).to respond_to(:deflate)
+    end
+
+    it 'responds to <<' do
+      expect(deflate).to respond_to(:<<)
+    end
+
+    it 'responds to flush' do
+      expect(deflate).to respond_to(:flush)
+    end
+
+    it 'responds to params' do
+      expect(deflate).to respond_to(:params)
+    end
+
+    it 'responds to set_dictionary' do
+      expect(deflate).to respond_to(:set_dictionary)
+    end
+  end
+end

data/spec/zlib/gzip_file_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+########################################################################
+# gzip_file_spec.rb
+#
+# Spec for the Zlib::GzipFile base class.
+########################################################################
+require 'spec_helper'
+
+RSpec.describe Zlib::GzipFile do
+  let(:gz_file) { described_class.new }
+
+  describe 'constants' do
+    it 'has the correct constant values' do
+      expect(described_class::GZ_MAGIC1).to eq(0x1f)
+      expect(described_class::GZ_MAGIC2).to eq(0x8b)
+      expect(described_class::GZ_METHOD_DEFLATE).to eq(8)
+      expect(described_class::GZ_FLAG_MULTIPART).to eq(0x2)
+      expect(described_class::GZ_FLAG_EXTRA).to eq(0x4)
+      expect(described_class::GZ_FLAG_ORIG_NAME).to eq(0x8)
+      expect(described_class::GZ_FLAG_COMMENT).to eq(0x10)
+      expect(described_class::GZ_FLAG_ENCRYPT).to eq(0x20)
+      expect(described_class::GZ_FLAG_UNKNOWN_MASK).to eq(0xc0)
+      expect(described_class::GZ_EXTRAFLAG_FAST).to eq(0x4)
+      expect(described_class::GZ_EXTRAFLAG_SLOW).to eq(0x2)
+    end
+  end
+
+  describe 'instance methods' do
+    it 'responds to GZFILE_IS_FINISHED' do
+      expect(gz_file).to respond_to(:GZFILE_IS_FINISHED)
+    end
+
+    it 'responds to gzfile_close' do
+      expect(gz_file).to respond_to(:gzfile_close)
+    end
+
+    it 'responds to to_io' do
+      expect(gz_file).to respond_to(:to_io)
+    end
+
+    it 'responds to crc' do
+      expect(gz_file).to respond_to(:crc)
+    end
+
+    it 'responds to mtime' do
+      expect(gz_file).to respond_to(:mtime)
+    end
+
+    it 'responds to level' do
+      expect(gz_file).to respond_to(:level)
+    end
+
+    it 'responds to os_code' do
+      expect(gz_file).to respond_to(:os_code)
+    end
+
+    it 'responds to orig_name' do
+      expect(gz_file).to respond_to(:orig_name)
+    end
+
+    it 'responds to comment' do
+      expect(gz_file).to respond_to(:comment)
+    end
+
+    it 'responds to close' do
+      expect(gz_file).to respond_to(:close)
+    end
+
+    it 'responds to finish' do
+      expect(gz_file).to respond_to(:finish)
+    end
+
+    it 'responds to closed?' do
+      expect(gz_file).to respond_to(:closed?)
+    end
+
+    it 'responds to sync' do
+      expect(gz_file).to respond_to(:sync)
+    end
+
+    it 'responds to sync=' do
+      expect(gz_file).to respond_to(:sync=)
+    end
+  end
+end

data/spec/zlib/gzip_reader_spec.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+########################################################################
+# gzip_reader_spec.rb
+#
+# Spec for the Zlib::GzipReader class.
+########################################################################
+require 'spec_helper'
+require 'fileutils'
+
+RSpec.describe Zlib::GzipReader do
+  before(:all) do
+    # Set up test file paths
+    @original_dir = Dir.pwd
+    @spec_dir = File.join(@original_dir, 'spec')
+    @test_txt = File.join(@spec_dir, 'test.txt')
+    @gz_file_path = File.join(@spec_dir, 'test.txt.gz')
+
+    # Ensure spec directory exists
+    Dir.mkdir(@spec_dir) unless Dir.exist?(@spec_dir)
+
+    # Clean up any existing files first
+    File.delete(@test_txt) if File.exist?(@test_txt)
+    File.delete(@gz_file_path) if File.exist?(@gz_file_path)
+
+    # Create test file and gzip it
+    File.open(@test_txt, 'wb') { |fh| fh.puts 'Test file' }
+    Dir.chdir(@spec_dir) do
+      system('gzip test.txt')
+    end
+
+    @gz_file = @gz_file_path
+  end
+
+  after(:all) do
+    # Clean up test files
+    [@test_txt, @gz_file_path].each do |file|
+      File.delete(file) if File.exist?(file)
+    end
+    # Also clean up any leftover files in spec directory
+    Dir.glob(File.join(@spec_dir, 'test.txt*')).each { |f| File.delete(f) rescue nil }
+  end
+
+  let(:handle) { File.open(@gz_file) }
+  let(:gz_reader) { described_class.new(handle) }
+
+  after do
+    handle.close if handle && !handle.closed?
+  end
+
+  describe 'constructor' do
+    it 'raises ArgumentError with no arguments' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+
+    it 'raises NoMethodError with invalid argument' do
+      expect { described_class.new(1) }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#lineno' do
+    it 'responds to lineno getter' do
+      expect(gz_reader).to respond_to(:lineno)
+    end
+
+    it 'can get lineno without errors' do
+      expect { gz_reader.lineno }.not_to raise_error
+    end
+
+    it 'returns an integer' do
+      expect(gz_reader.lineno).to be_a(Integer)
+    end
+
+    it 'starts at 0' do
+      expect(gz_reader.lineno).to eq(0)
+    end
+
+    it 'responds to lineno setter' do
+      expect(gz_reader).to respond_to(:lineno=)
+    end
+
+    it 'can set lineno without errors' do
+      expect { gz_reader.lineno = 0 }.not_to raise_error
+    end
+
+    it 'returns the set value' do
+      expect(gz_reader.lineno = 0).to eq(0)
+    end
+  end
+
+  describe '#eof' do
+    it 'responds to eof' do
+      expect(gz_reader).to respond_to(:eof)
+    end
+
+    it 'can call eof without errors' do
+      expect { gz_reader.eof }.not_to raise_error
+    end
+  end
+
+  describe '#pos' do
+    it 'responds to pos' do
+      expect(gz_reader).to respond_to(:pos)
+    end
+
+    it 'can call pos without errors' do
+      expect { gz_reader.pos }.not_to raise_error
+    end
+
+    it 'returns an integer' do
+      expect(gz_reader.pos).to be_a(Integer)
+    end
+  end
+
+  describe '#rewind' do
+    it 'responds to rewind' do
+      expect(gz_reader).to respond_to(:rewind)
+    end
+
+    it 'can call rewind without errors' do
+      expect { gz_reader.rewind }.not_to raise_error
+    end
+
+    it 'returns 0' do
+      expect(gz_reader.rewind).to eq(0)
+    end
+  end
+
+  describe '#unused' do
+    it 'responds to unused' do
+      expect(gz_reader).to respond_to(:unused)
+    end
+
+    it 'can call unused without errors' do
+      expect { gz_reader.unused }.not_to raise_error
+    end
+
+    it 'returns nil initially' do
+      expect(gz_reader.unused).to be_nil
+    end
+  end
+
+  describe '#read' do
+    it 'responds to read' do
+      expect(gz_reader).to respond_to(:read)
+    end
+
+    it 'can call read without errors' do
+      expect { gz_reader.read }.not_to raise_error
+    end
+
+    it 'reads the entire file content' do
+      expect(gz_reader.read).to eq("Test file\n")
+    end
+
+    it 'can read with length parameter' do
+      expect(gz_reader.read(4)).to eq("Test")
+    end
+
+    it 'raises ArgumentError for negative length' do
+      expect { gz_reader.read(-1) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#getc' do
+    it 'responds to getc' do
+      expect(gz_reader).to respond_to(:getc)
+    end
+
+    it 'can call getc without errors' do
+      expect { gz_reader.getc }.not_to raise_error
+    end
+
+    it 'returns the first character' do
+      expect(gz_reader.getc).to eq('T')
+    end
+  end
+
+  describe '#readchar' do
+    it 'responds to readchar' do
+      expect(gz_reader).to respond_to(:readchar)
+    end
+
+    it 'can call readchar without errors' do
+      expect { gz_reader.readchar }.not_to raise_error
+    end
+
+    it 'returns the first character' do
+      expect(gz_reader.readchar).to eq('T')
+    end
+  end
+
+  describe '#each_byte' do
+    it 'responds to each_byte' do
+      expect(gz_reader).to respond_to(:each_byte)
+    end
+
+    it 'can call each_byte without errors' do
+      expect { gz_reader.each_byte {} }.not_to raise_error
+    end
+
+    it 'returns nil when called with block' do
+      expect(gz_reader.each_byte {}).to be_nil
+    end
+  end
+
+  describe '#ungetc' do
+    it 'responds to ungetc' do
+      expect(gz_reader).to respond_to(:ungetc)
+    end
+
+    it 'can call ungetc without errors' do
+      expect { gz_reader.ungetc(99) }.not_to raise_error
+    end
+
+    it 'returns nil' do
+      expect(gz_reader.ungetc(99)).to be_nil
+    end
+  end
+
+  describe '#gets' do
+    it 'responds to gets' do
+      expect(gz_reader).to respond_to(:gets)
+    end
+
+    it 'can call gets without errors' do
+      expect { gz_reader.gets }.not_to raise_error
+    end
+
+    it 'reads a line' do
+      expect(gz_reader.gets).to eq("Test file\n")
+    end
+  end
+
+  describe '#readline' do
+    it 'responds to readline' do
+      expect(gz_reader).to respond_to(:readline)
+    end
+
+    it 'can call readline without errors' do
+      expect { gz_reader.readline }.not_to raise_error
+    end
+
+    it 'reads a line' do
+      expect(gz_reader.readline).to eq("Test file\n")
+    end
+  end
+
+  describe '#each' do
+    it 'responds to each' do
+      expect(gz_reader).to respond_to(:each)
+    end
+
+    it 'can call each without errors' do
+      expect { gz_reader.each {} }.not_to raise_error
+    end
+
+    it 'returns non-nil when called with block' do
+      expect(gz_reader.each {}).not_to be_nil
+    end
+  end
+
+  describe '#readlines' do
+    it 'responds to readlines' do
+      expect(gz_reader).to respond_to(:readlines)
+    end
+
+    it 'can call readlines without errors' do
+      expect { gz_reader.readlines }.not_to raise_error
+    end
+
+    it 'returns array of lines' do
+      expect(gz_reader.readlines).to eq(["Test file\n"])
+    end
+  end
+end