compress-bsc 1.0.0

data/spec/compressor_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+RSpec.describe Compress::BSC::Compressor do
+  let(:test_data) { "Hello, World! This is a test for BSC compression." * 50 }
+
+  describe '#initialize' do
+    it 'creates a compressor with default options' do
+      compressor = Compress::BSC::Compressor.new
+      expect(compressor.lzp_hash_size).to eq(0)
+      expect(compressor.lzp_min_len).to eq(0)
+      expect(compressor.block_sorter).to eq(Compress::BSC::Library::LIBBSC_DEFAULT_BLOCKSORTER)
+      expect(compressor.coder).to eq(Compress::BSC::Library::LIBBSC_DEFAULT_CODER)
+      expect(compressor.features).to eq(Compress::BSC::Library::LIBBSC_DEFAULT_FEATURES)
+    end
+
+    it 'creates a compressor with custom options' do
+      options = {
+        lzp_hash_size: 16,
+        lzp_min_len: 64,
+        block_sorter: Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT,
+        coder: Compress::BSC::Library::LIBBSC_CODER_QLFC_ADAPTIVE,
+        features: Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE
+      }
+
+      compressor = Compress::BSC::Compressor.new(options)
+      expect(compressor.lzp_hash_size).to eq(16)
+      expect(compressor.lzp_min_len).to eq(64)
+      expect(compressor.block_sorter).to eq(Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT)
+      expect(compressor.coder).to eq(Compress::BSC::Library::LIBBSC_CODER_QLFC_ADAPTIVE)
+      expect(compressor.features).to eq(Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE)
+    end
+  end
+
+  describe '#compress' do
+    let(:compressor) { Compress::BSC::Compressor.new }
+
+    it 'compresses data successfully' do
+      result = compressor.compress(test_data)
+      expect(result).to be_a(String)
+      expect(result.bytesize).to be > 0
+      expect(result.bytesize).to be <= test_data.bytesize + Compress::BSC::Library::LIBBSC_HEADER_SIZE
+    end
+
+    it 'handles empty data' do
+      result = compressor.compress("")
+      expect(result).to eq("")
+    end
+
+    it 'handles small data' do
+      small_data = "Hi"
+      result = compressor.compress(small_data)
+      expect(result).to be_a(String)
+    end
+
+    it 'raises error for nil input' do
+      expect { compressor.compress(nil) }.to raise_error(ArgumentError, "Input data cannot be nil")
+    end
+
+    it 'raises error for non-string input' do
+      expect { compressor.compress(123) }.to raise_error(ArgumentError, "Input data must be a string")
+    end
+
+    context 'with different compression settings' do
+      it 'compresses with LZP enabled' do
+        compressor = Compress::BSC::Compressor.new(
+          lzp_hash_size: Compress::BSC::Library::LIBBSC_DEFAULT_LZPHASHSIZE,
+          lzp_min_len: Compress::BSC::Library::LIBBSC_DEFAULT_LZPMINLEN
+        )
+
+        result = compressor.compress(test_data)
+        expect(result).to be_a(String)
+        expect(result.bytesize).to be > 0
+      end
+
+      it 'compresses with different block sorters' do
+        [
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT,
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST3,
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST4
+        ].each do |sorter|
+          compressor = Compress::BSC::Compressor.new(block_sorter: sorter)
+          result = compressor.compress(test_data)
+          expect(result).to be_a(String)
+          expect(result.bytesize).to be > 0
+        end
+      end
+
+      it 'compresses with different coders' do
+        [
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_STATIC,
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_ADAPTIVE,
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_FAST
+        ].each do |coder|
+          compressor = Compress::BSC::Compressor.new(coder: coder)
+          result = compressor.compress(test_data)
+          expect(result).to be_a(String)
+          expect(result.bytesize).to be > 0
+        end
+      end
+    end
+  end
+
+  describe '#compress_file' do
+    let(:compressor) { Compress::BSC::Compressor.new }
+    let(:input_file) { 'spec/test_input.txt' }
+    let(:output_file) { 'spec/test_output.bsc' }
+
+    before do
+      File.write(input_file, test_data)
+    end
+
+    after do
+      [input_file, output_file].each { |f| File.delete(f) if File.exist?(f) }
+    end
+
+    it 'compresses a file successfully' do
+      result_size = compressor.compress_file(input_file, output_file)
+
+      expect(File.exist?(output_file)).to be true
+      expect(result_size).to be > 0
+      expect(result_size).to eq(File.size(output_file))
+    end
+  end
+end

data/spec/decompressor_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+RSpec.describe Compress::BSC::Decompressor do
+  let(:test_data) { "Hello, World! This is a test for BSC decompression." * 50 }
+  let(:compressor) { Compress::BSC::Compressor.new }
+  let(:compressed_data) { compressor.compress(test_data) }
+
+  describe '#initialize' do
+    it 'creates a decompressor with default options' do
+      decompressor = Compress::BSC::Decompressor.new
+      expect(decompressor.features).to eq(Compress::BSC::Library::LIBBSC_DEFAULT_FEATURES)
+    end
+
+    it 'creates a decompressor with custom options' do
+      decompressor = Compress::BSC::Decompressor.new(features: Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE)
+      expect(decompressor.features).to eq(Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE)
+    end
+  end
+
+  describe '#decompress' do
+    let(:decompressor) { Compress::BSC::Decompressor.new }
+
+    it 'decompresses data successfully' do
+      result = decompressor.decompress(compressed_data)
+      expect(result).to eq(test_data)
+    end
+
+    it 'handles empty data' do
+      result = decompressor.decompress("")
+      expect(result).to eq("")
+    end
+
+    it 'raises error for nil input' do
+      expect { decompressor.decompress(nil) }.to raise_error(ArgumentError, "Compressed data cannot be nil")
+    end
+
+    it 'raises error for non-string input' do
+      expect { decompressor.decompress(123) }.to raise_error(ArgumentError, "Compressed data must be a string")
+    end
+
+    it 'raises error for data too small to contain header' do
+      small_data = "x" * (Compress::BSC::Library::LIBBSC_HEADER_SIZE - 1)
+      expect { decompressor.decompress(small_data) }.to raise_error(Compress::BSC::Error)
+    end
+
+    it 'raises error for corrupted data' do
+      corrupted_data = "corrupted" + "\x00" * (Compress::BSC::Library::LIBBSC_HEADER_SIZE - 9)
+      expect { decompressor.decompress(corrupted_data) }.to raise_error(Compress::BSC::Error)
+    end
+
+    context 'with different compression settings' do
+      it 'decompresses data compressed with LZP' do
+        lzp_compressor = Compress::BSC::Compressor.new(
+          lzp_hash_size: Compress::BSC::Library::LIBBSC_DEFAULT_LZPHASHSIZE,
+          lzp_min_len: Compress::BSC::Library::LIBBSC_DEFAULT_LZPMINLEN
+        )
+
+        lzp_compressed = lzp_compressor.compress(test_data)
+        result = decompressor.decompress(lzp_compressed)
+        expect(result).to eq(test_data)
+      end
+
+      it 'decompresses data compressed with different block sorters' do
+        [
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT,
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST3,
+          Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST4
+        ].each do |sorter|
+          sorter_compressor = Compress::BSC::Compressor.new(block_sorter: sorter)
+          sorter_compressed = sorter_compressor.compress(test_data)
+          result = decompressor.decompress(sorter_compressed)
+          expect(result).to eq(test_data)
+        end
+      end
+
+      it 'decompresses data compressed with different coders' do
+        [
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_STATIC,
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_ADAPTIVE,
+          Compress::BSC::Library::LIBBSC_CODER_QLFC_FAST
+        ].each do |coder|
+          coder_compressor = Compress::BSC::Compressor.new(coder: coder)
+          coder_compressed = coder_compressor.compress(test_data)
+          result = decompressor.decompress(coder_compressed)
+          expect(result).to eq(test_data)
+        end
+      end
+    end
+  end
+
+  describe '#decompress_file' do
+    let(:decompressor) { Compress::BSC::Decompressor.new }
+    let(:input_file) { 'spec/test_compressed.bsc' }
+    let(:output_file) { 'spec/test_decompressed.txt' }
+
+    before do
+      File.binwrite(input_file, compressed_data)
+    end
+
+    after do
+      [input_file, output_file].each { |f| File.delete(f) if File.exist?(f) }
+    end
+
+    it 'decompresses a file successfully' do
+      result_size = decompressor.decompress_file(input_file, output_file)
+
+      expect(File.exist?(output_file)).to be true
+      expect(result_size).to eq(test_data.bytesize)
+      expect(File.binread(output_file)).to eq(test_data)
+    end
+  end
+
+  describe '.block_info' do
+    it 'returns correct block information' do
+      info = Compress::BSC::Decompressor.block_info(compressed_data)
+
+      expect(info).to be_a(Hash)
+      expect(info[:block_size]).to be > 0
+      expect(info[:data_size]).to eq(test_data.bytesize)
+    end
+
+    it 'raises error for nil input' do
+      expect { Compress::BSC::Decompressor.block_info(nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error for non-string input' do
+      expect { Compress::BSC::Decompressor.block_info(123) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error for data too small' do
+      small_data = "x" * (Compress::BSC::Library::LIBBSC_HEADER_SIZE - 1)
+      expect { Compress::BSC::Decompressor.block_info(small_data) }.to raise_error(Compress::BSC::Error)
+    end
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe Compress::BSC::Error do
+  describe '#initialize' do
+    it 'creates an error with code and message' do
+      error = Compress::BSC::Error.new(Compress::BSC::Library::LIBBSC_BAD_PARAMETER)
+
+      expect(error.code).to eq(Compress::BSC::Library::LIBBSC_BAD_PARAMETER)
+      expect(error.error_name).to eq('LIBBSC_BAD_PARAMETER')
+      expect(error.message).to include('LIBBSC_BAD_PARAMETER')
+      expect(error.message).to include(Compress::BSC::Library::LIBBSC_BAD_PARAMETER.to_s)
+    end
+
+    it 'handles unknown error codes' do
+      unknown_code = -999
+      error = Compress::BSC::Error.new(unknown_code)
+
+      expect(error.code).to eq(unknown_code)
+      expect(error.error_name).to eq("UNKNOWN_ERROR(#{unknown_code})")
+    end
+  end
+
+  describe '.check_result' do
+    it 'returns the result for successful operations' do
+      result = Compress::BSC::Error.check_result(Compress::BSC::Library::LIBBSC_NO_ERROR)
+      expect(result).to eq(Compress::BSC::Library::LIBBSC_NO_ERROR)
+
+      positive_result = Compress::BSC::Error.check_result(100)
+      expect(positive_result).to eq(100)
+    end
+
+    it 'raises error for negative error codes' do
+      expect {
+        Compress::BSC::Error.check_result(Compress::BSC::Library::LIBBSC_BAD_PARAMETER)
+      }.to raise_error(Compress::BSC::Error) do |error|
+        expect(error.code).to eq(Compress::BSC::Library::LIBBSC_BAD_PARAMETER)
+      end
+    end
+
+    it 'handles all defined error codes' do
+      error_codes = [
+        Compress::BSC::Library::LIBBSC_BAD_PARAMETER,
+        Compress::BSC::Library::LIBBSC_NOT_ENOUGH_MEMORY,
+        Compress::BSC::Library::LIBBSC_NOT_COMPRESSIBLE,
+        Compress::BSC::Library::LIBBSC_NOT_SUPPORTED,
+        Compress::BSC::Library::LIBBSC_UNEXPECTED_EOB,
+        Compress::BSC::Library::LIBBSC_DATA_CORRUPT,
+        Compress::BSC::Library::LIBBSC_GPU_ERROR,
+        Compress::BSC::Library::LIBBSC_GPU_NOT_SUPPORTED,
+        Compress::BSC::Library::LIBBSC_GPU_NOT_ENOUGH_MEMORY
+      ]
+
+      error_codes.each do |code|
+        expect {
+          Compress::BSC::Error.check_result(code)
+        }.to raise_error(Compress::BSC::Error) do |error|
+          expect(error.code).to eq(code)
+          expect(error.error_name).not_to include('UNKNOWN_ERROR')
+        end
+      end
+    end
+  end
+end

data/spec/examples.txt

@@ -0,0 +1,60 @@
+example_id                           | status | run_time        |
+------------------------------------ | ------ | --------------- |
+./spec/compressor_spec.rb[1:1:1]     | passed | 0.00046 seconds |
+./spec/compressor_spec.rb[1:1:2]     | passed | 0.00007 seconds |
+./spec/compressor_spec.rb[1:2:1]     | passed | 0.00191 seconds |
+./spec/compressor_spec.rb[1:2:2]     | passed | 0.00008 seconds |
+./spec/compressor_spec.rb[1:2:3]     | passed | 0.0009 seconds  |
+./spec/compressor_spec.rb[1:2:4]     | passed | 0.00011 seconds |
+./spec/compressor_spec.rb[1:2:5]     | passed | 0.00008 seconds |
+./spec/compressor_spec.rb[1:2:6:1]   | passed | 0.00207 seconds |
+./spec/compressor_spec.rb[1:2:6:2]   | passed | 0.00662 seconds |
+./spec/compressor_spec.rb[1:2:6:3]   | passed | 0.00215 seconds |
+./spec/compressor_spec.rb[1:3:1]     | passed | 0.0103 seconds  |
+./spec/decompressor_spec.rb[1:1:1]   | passed | 0.00005 seconds |
+./spec/decompressor_spec.rb[1:1:2]   | passed | 0.00007 seconds |
+./spec/decompressor_spec.rb[1:2:1]   | passed | 0.00274 seconds |
+./spec/decompressor_spec.rb[1:2:2]   | passed | 0.00009 seconds |
+./spec/decompressor_spec.rb[1:2:3]   | passed | 0.00024 seconds |
+./spec/decompressor_spec.rb[1:2:4]   | passed | 0.00016 seconds |
+./spec/decompressor_spec.rb[1:2:5]   | passed | 0.00009 seconds |
+./spec/decompressor_spec.rb[1:2:6]   | passed | 0.00013 seconds |
+./spec/decompressor_spec.rb[1:2:7:1] | passed | 0.00278 seconds |
+./spec/decompressor_spec.rb[1:2:7:2] | passed | 0.00569 seconds |
+./spec/decompressor_spec.rb[1:2:7:3] | passed | 0.00429 seconds |
+./spec/decompressor_spec.rb[1:3:1]   | passed | 0.00213 seconds |
+./spec/decompressor_spec.rb[1:4:1]   | passed | 0.00091 seconds |
+./spec/decompressor_spec.rb[1:4:2]   | passed | 0.0001 seconds  |
+./spec/decompressor_spec.rb[1:4:3]   | passed | 0.00009 seconds |
+./spec/decompressor_spec.rb[1:4:4]   | passed | 0.00006 seconds |
+./spec/error_spec.rb[1:1:1]          | passed | 0.005 seconds   |
+./spec/error_spec.rb[1:1:2]          | passed | 0.00146 seconds |
+./spec/error_spec.rb[1:2:1]          | passed | 0.00006 seconds |
+./spec/error_spec.rb[1:2:2]          | passed | 0.00174 seconds |
+./spec/error_spec.rb[1:2:3]          | passed | 0.00035 seconds |
+./spec/ffi_bsc_spec.rb[1:1:1]        | passed | 0.00062 seconds |
+./spec/ffi_bsc_spec.rb[1:2:1:1]      | passed | 0.00368 seconds |
+./spec/ffi_bsc_spec.rb[1:2:2:1]      | passed | 0.00042 seconds |
+./spec/ffi_bsc_spec.rb[1:2:3:1]      | passed | 0.00041 seconds |
+./spec/ffi_bsc_spec.rb[1:2:4:1]      | passed | 0.00197 seconds |
+./spec/ffi_bsc_spec.rb[1:2:4:2]      | passed | 0.0017 seconds  |
+./spec/ffi_bsc_spec.rb[1:2:5:1]      | passed | 0.00048 seconds |
+./spec/ffi_bsc_spec.rb[1:2:5:2]      | passed | 0.00057 seconds |
+./spec/ffi_bsc_spec.rb[1:2:5:3]      | passed | 0.00041 seconds |
+./spec/ffi_bsc_spec.rb[1:3:1]        | passed | 0.00036 seconds |
+./spec/ffi_bsc_spec.rb[1:3:2]        | passed | 0.00102 seconds |
+./spec/ffi_bsc_spec.rb[1:3:3]        | passed | 0.00164 seconds |
+./spec/ffi_bsc_spec.rb[1:3:4]        | passed | 0.00207 seconds |
+./spec/ffi_bsc_spec.rb[1:3:5]        | passed | 0.00164 seconds |
+./spec/ffi_bsc_spec.rb[1:3:6]        | passed | 0.00033 seconds |
+./spec/library_spec.rb[1:1:1]        | passed | 0.00006 seconds |
+./spec/library_spec.rb[1:1:2]        | passed | 0.00007 seconds |
+./spec/library_spec.rb[1:1:3]        | passed | 0.00035 seconds |
+./spec/library_spec.rb[1:1:4]        | passed | 0.00006 seconds |
+./spec/library_spec.rb[1:1:5]        | passed | 0.00006 seconds |
+./spec/library_spec.rb[1:1:6]        | passed | 0.00006 seconds |
+./spec/library_spec.rb[1:1:7]        | passed | 0.00005 seconds |
+./spec/library_spec.rb[1:2:1]        | passed | 0.00038 seconds |
+./spec/library_spec.rb[1:2:2]        | passed | 0.00006 seconds |
+./spec/library_spec.rb[1:3:1]        | passed | 0.00232 seconds |
+./spec/library_spec.rb[1:3:2]        | passed | 0.00044 seconds |

data/spec/ffi_bsc_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+RSpec.describe Compress::BSC do
+  let(:bsc) { Compress::BSC.new }
+
+  describe '#initialize' do
+    it 'initializes the BSC library without error' do
+      expect { Compress::BSC.new }.not_to raise_error
+    end
+  end
+
+  describe '#compress and #decompress' do
+    let(:test_data) { "Hello, World! This is a test string for BSC compression." * 100 }
+    let(:empty_data) { "" }
+    let(:small_data) { "Hi" }
+
+    context 'with regular data' do
+      it 'compresses and decompresses data correctly' do
+        compressed = bsc.compress(test_data)
+        expect(compressed).to be_a(String)
+        expect(compressed.bytesize).to be > 0
+
+        decompressed = bsc.decompress(compressed)
+        expect(decompressed).to eq(test_data)
+      end
+    end
+
+    context 'with empty data' do
+      it 'handles empty data correctly' do
+        compressed = bsc.compress(empty_data)
+        expect(compressed).to eq(empty_data)
+
+        decompressed = bsc.decompress(empty_data)
+        expect(decompressed).to eq(empty_data)
+      end
+    end
+
+    context 'with small data' do
+      it 'handles small data correctly' do
+        compressed = bsc.compress(small_data)
+        expect(compressed).to be_a(String)
+
+        decompressed = bsc.decompress(compressed)
+        expect(decompressed).to eq(small_data)
+      end
+    end
+
+    context 'with different compression options' do
+      it 'compresses with BWT block sorter' do
+        compressed = bsc.compress(test_data, block_sorter: Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT)
+        decompressed = bsc.decompress(compressed)
+        expect(decompressed).to eq(test_data)
+      end
+
+      it 'compresses with different coders' do
+        Compress::BSC::Library::LIBBSC_CODER_QLFC_STATIC.tap do |coder|
+          compressed = bsc.compress(test_data, coder: coder)
+          decompressed = bsc.decompress(compressed)
+          expect(decompressed).to eq(test_data)
+        end
+      end
+    end
+
+    context 'error handling' do
+      it 'raises error for nil input' do
+        expect { bsc.compress(nil) }.to raise_error(ArgumentError)
+        expect { bsc.decompress(nil) }.to raise_error(ArgumentError)
+      end
+
+      it 'raises error for non-string input' do
+        expect { bsc.compress(123) }.to raise_error(ArgumentError)
+        expect { bsc.decompress(123) }.to raise_error(ArgumentError)
+      end
+
+      it 'raises error for corrupted compressed data' do
+        corrupted_data = "corrupted" + "\x00" * 20
+        expect { bsc.decompress(corrupted_data) }.to raise_error(Compress::BSC::Error)
+      end
+    end
+  end
+
+  describe 'round-trip compression with various data types' do
+    test_data = [
+      "Simple ASCII text",
+      "Unicode text: 你好世界 🌍",
+      "\x00\x01\x02\x03" * 100, # Binary data
+      "A" * 10000,               # Repetitive data
+      Random.bytes(1000),        # Random data
+      "Mixed\x00data\xFF\x80with\x01binary"
+    ]
+
+    test_data.each_with_index do |data, index|
+      it "correctly handles test case #{index + 1}" do
+        compressed = bsc.compress(data)
+        decompressed = bsc.decompress(compressed)
+        expect(decompressed).to eq(data)
+        expect(decompressed.encoding).to eq(data.encoding)
+      end
+    end
+  end
+end

data/spec/library_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+RSpec.describe Compress::BSC::Library do
+  describe 'constants' do
+    it 'defines version constants' do
+      expect(Compress::BSC::Library::LIBBSC_VERSION_MAJOR).to eq(3)
+      expect(Compress::BSC::Library::LIBBSC_VERSION_MINOR).to eq(3)
+      expect(Compress::BSC::Library::LIBBSC_VERSION_PATCH).to eq(9)
+      expect(Compress::BSC::Library::LIBBSC_VERSION_STRING).to eq("3.3.9")
+    end
+
+    it 'defines error constants' do
+      expect(Compress::BSC::Library::LIBBSC_NO_ERROR).to eq(0)
+      expect(Compress::BSC::Library::LIBBSC_BAD_PARAMETER).to eq(-1)
+      expect(Compress::BSC::Library::LIBBSC_NOT_ENOUGH_MEMORY).to eq(-2)
+      expect(Compress::BSC::Library::LIBBSC_NOT_COMPRESSIBLE).to eq(-3)
+      expect(Compress::BSC::Library::LIBBSC_NOT_SUPPORTED).to eq(-4)
+      expect(Compress::BSC::Library::LIBBSC_UNEXPECTED_EOB).to eq(-5)
+      expect(Compress::BSC::Library::LIBBSC_DATA_CORRUPT).to eq(-6)
+      expect(Compress::BSC::Library::LIBBSC_GPU_ERROR).to eq(-7)
+      expect(Compress::BSC::Library::LIBBSC_GPU_NOT_SUPPORTED).to eq(-8)
+      expect(Compress::BSC::Library::LIBBSC_GPU_NOT_ENOUGH_MEMORY).to eq(-9)
+    end
+
+    it 'defines block sorter constants' do
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_NONE).to eq(0)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT).to eq(1)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST3).to eq(3)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST4).to eq(4)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST5).to eq(5)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST6).to eq(6)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST7).to eq(7)
+      expect(Compress::BSC::Library::LIBBSC_BLOCKSORTER_ST8).to eq(8)
+    end
+
+    it 'defines coder constants' do
+      expect(Compress::BSC::Library::LIBBSC_CODER_NONE).to eq(0)
+      expect(Compress::BSC::Library::LIBBSC_CODER_QLFC_STATIC).to eq(1)
+      expect(Compress::BSC::Library::LIBBSC_CODER_QLFC_ADAPTIVE).to eq(2)
+      expect(Compress::BSC::Library::LIBBSC_CODER_QLFC_FAST).to eq(3)
+    end
+
+    it 'defines feature constants' do
+      expect(Compress::BSC::Library::LIBBSC_FEATURE_NONE).to eq(0)
+      expect(Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE).to eq(1)
+      expect(Compress::BSC::Library::LIBBSC_FEATURE_MULTITHREADING).to eq(2)
+      expect(Compress::BSC::Library::LIBBSC_FEATURE_LARGEPAGES).to eq(4)
+      expect(Compress::BSC::Library::LIBBSC_FEATURE_CUDA).to eq(8)
+    end
+
+    it 'defines default constants' do
+      expect(Compress::BSC::Library::LIBBSC_DEFAULT_LZPHASHSIZE).to eq(15)
+      expect(Compress::BSC::Library::LIBBSC_DEFAULT_LZPMINLEN).to eq(128)
+      expect(Compress::BSC::Library::LIBBSC_DEFAULT_BLOCKSORTER).to eq(Compress::BSC::Library::LIBBSC_BLOCKSORTER_BWT)
+      expect(Compress::BSC::Library::LIBBSC_DEFAULT_CODER).to eq(Compress::BSC::Library::LIBBSC_CODER_QLFC_STATIC)
+      expect(Compress::BSC::Library::LIBBSC_DEFAULT_FEATURES).to eq(
+        Compress::BSC::Library::LIBBSC_FEATURE_FASTMODE | Compress::BSC::Library::LIBBSC_FEATURE_MULTITHREADING
+      )
+    end
+
+    it 'defines header size constant' do
+      expect(Compress::BSC::Library::LIBBSC_HEADER_SIZE).to eq(28)
+    end
+  end
+
+  describe '.error_name' do
+    it 'returns correct error names for known codes' do
+      expect(Compress::BSC::Library.error_name(Compress::BSC::Library::LIBBSC_NO_ERROR)).to eq('LIBBSC_NO_ERROR')
+      expect(Compress::BSC::Library.error_name(Compress::BSC::Library::LIBBSC_BAD_PARAMETER)).to eq('LIBBSC_BAD_PARAMETER')
+      expect(Compress::BSC::Library.error_name(Compress::BSC::Library::LIBBSC_NOT_ENOUGH_MEMORY)).to eq('LIBBSC_NOT_ENOUGH_MEMORY')
+      expect(Compress::BSC::Library.error_name(Compress::BSC::Library::LIBBSC_DATA_CORRUPT)).to eq('LIBBSC_DATA_CORRUPT')
+    end
+
+    it 'returns unknown error format for unknown codes' do
+      expect(Compress::BSC::Library.error_name(-999)).to eq('UNKNOWN_ERROR(-999)')
+      expect(Compress::BSC::Library.error_name(123)).to eq('UNKNOWN_ERROR(123)')
+    end
+  end
+
+  describe 'function bindings' do
+    it 'has the required function bindings' do
+      expect(Compress::BSC::Library).to respond_to(:bsc_init)
+      expect(Compress::BSC::Library).to respond_to(:bsc_init_full)
+      expect(Compress::BSC::Library).to respond_to(:bsc_compress)
+      expect(Compress::BSC::Library).to respond_to(:bsc_decompress)
+      expect(Compress::BSC::Library).to respond_to(:bsc_block_info)
+      expect(Compress::BSC::Library).to respond_to(:bsc_malloc)
+      expect(Compress::BSC::Library).to respond_to(:bsc_zero_malloc)
+      expect(Compress::BSC::Library).to respond_to(:bsc_free)
+    end
+
+    it 'can call bsc_init successfully' do
+      result = Compress::BSC::Library.bsc_init(Compress::BSC::Library::LIBBSC_DEFAULT_FEATURES)
+      expect(result).to eq(Compress::BSC::Library::LIBBSC_NO_ERROR)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+# Coverage reporting setup
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/examples/'
+    add_filter '/bin/'
+    coverage_dir 'coverage'
+
+    add_group 'Library', 'lib'
+
+    # Minimum coverage thresholds
+    minimum_coverage 80
+    minimum_coverage_by_file 70
+  end
+end
+
+require_relative '../lib/compress/bsc'
+
+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
+
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+
+  # Initialize BSC library before running tests
+  config.before(:suite) do
+    begin
+      Compress::BSC.new
+    rescue Compress::BSC::Error => e
+      warn "Warning: Could not initialize BSC library: #{e.message}"
+      warn "Some tests may fail. Please ensure libbsc is installed."
+    rescue LoadError => e
+      warn "Warning: Could not load BSC library: #{e.message}"
+      warn "Please install libbsc library. See README for instructions."
+    end
+  end
+end