lz4-ruby 0.2.0-java → 0.3.0-java

data/spec/lz4_compressHC_spec.rb

@@ -17,6 +17,10 @@ describe "LZ4::compress" do
     compressed = LZ4.compressHC(text)
     uncompressed = LZ4.uncompress(compressed)
 
+    it "should be compressed length less than original text" do
+      expect(compressed.size).to be < text.length
+    end
+
     it "should be able to uncompress" do
       expect(uncompressed).to eql(text)
     end

data/spec/lz4_compress_spec.rb

@@ -17,6 +17,10 @@ describe "LZ4::compress" do
     compressed = LZ4.compress(text)
     uncompressed = LZ4.uncompress(compressed)
 
+    it "should be compressed length less than original text" do
+      expect(compressed.size).to be < text.length
+    end
+
     it "should be able to uncompress" do
       expect(uncompressed).to eql(text)
     end

data/spec/lz4_raw_compress_spec.rb

@@ -0,0 +1,152 @@
+require './spec/helper'
+
+describe "LZ4::Raw::compress" do
+  context "give empty text" do
+    compressed, size = LZ4::Raw.compress("")
+
+    expected = [0x00]
+
+    it "should be compressed to length #{expected.size}" do
+      expect(size).to eql(expected.size)
+      expect(compressed.size).to eql(expected.size)
+    end
+
+    it "should be compressed into '#{expected}'" do
+      expect(compressed).to eql(expected.pack("C*"))
+    end
+  end
+
+  context "give text #{text = "aaaaaaaaaaaaaaaaaaaa"}" do
+    expected = [0x1a, 0x61, 0x01, 0x00, 0x50, 0x61, 0x61, 0x61, 0x61, 0x61]
+
+    context "without output buffer" do
+      compressed, size = LZ4::Raw.compress(text)
+
+      it "should be compressed to length #{expected.size}" do
+        expect(size).to eql(expected.size)
+        expect(compressed.size).to eql(expected.size)
+      end
+
+      it "should be compressed into '#{expected}'" do
+        expect(compressed).to eql(expected.pack("C*"))
+      end
+    end
+    
+    context "with input_size" do
+      context "(3) which is less than input text length (#{text.length})" do
+        input_size = 3
+        compressed, size = LZ4::Raw.compress(text, :input_size => input_size)
+
+        aaa_ex = [0x30, 0x61, 0x61, 0x61]
+
+        it "should be compressed to length #{aaa_ex.size}" do
+          expect(size).to eql(aaa_ex.size)
+          expect(compressed.size).to eql(aaa_ex.size)
+        end
+
+        it "should be compressed into #{aaa_ex}" do
+          expect(compressed).to eql(aaa_ex.pack("C*"))
+        end
+      end
+
+      context "(30) which is greater than input text length (#{text.length})" do
+        input_size = 30
+        it "should be thrown ArgumentError" do
+          expect {
+            compressed, size = LZ4::Raw.compress(text, :input_size => input_size)
+          }.to raise_error(ArgumentError, "`:input_size` (30) must be less than or equal `source.length` (20)")
+        end
+      end
+    end
+
+    context "with output buffer" do
+      context "enough buffer size: 10" do
+        out_buf_size = 10
+        out_buf = " " * out_buf_size
+
+        compressed, size = LZ4::Raw.compress(text, :dest => out_buf)
+
+        it "should be compressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+        end
+
+        it "should be unchanged output buffer size" do
+          expect(compressed.size).to eql(out_buf_size)
+        end
+
+        it "should be compressed into '#{expected}'" do
+          expect(compressed[0, size]).to eql(expected.pack("C*"))
+        end
+
+        it "should be used output buffer" do
+          expect(compressed).to eql(out_buf)
+        end
+      end
+
+      context "poor buffer size: 3" do
+        out_buf_size = 3
+        out_buf = " " * out_buf_size
+
+        it "shoud be thrown LZ4Error" do
+          expect {
+            compressed, size = LZ4::Raw.compress(text, :dest => out_buf)
+          }.to raise_error(LZ4Error, "compression failed")
+        end
+      end
+    end
+
+    context "with max_output_size" do
+      context "enough max_output_size: 10" do
+        max_output_size = 10
+        compressed, size = LZ4::Raw.compress(text, :max_output_size => max_output_size)
+
+        it "should be compressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+        end
+
+        it "should be compressed into '#{expected}'" do
+          expect(compressed[0, size]).to eql(expected.pack("C*"))
+        end
+      end
+
+      context "poor max_output_size: 3" do
+        max_output_size = 3
+        it "shoud be thrown LZ4Error" do
+          expect {
+            compressed, size = LZ4::Raw.compress(text, :max_output_size => max_output_size)
+          }.to raise_error(LZ4Error, "compression failed")
+        end
+      end
+    end
+
+    context "with output buffer and max_output_size" do
+      context "when size of output buffer: 30, which is greater than max_output_size: 20" do
+        out_buf_size = 30
+        max_output_size = 20
+        out_buf = " " * out_buf_size
+
+        compressed, size = LZ4::Raw.compress(text, :dest => out_buf, :max_output_size => max_output_size)
+
+        it "should be compressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+        end
+
+        it "should be compressed into '#{expected}'" do
+          expect(compressed[0, size]).to eql(expected.pack("C*"))
+        end
+      end
+
+      context "when size of output buffer: 10, which is less than max_output_size: 20" do
+        out_buf_size = 10
+        max_output_size = 20
+        out_buf = " " * out_buf_size
+
+        it "should be thrown ArgumentError" do
+          expect {
+            compressed, size = LZ4::Raw.compress(text, :dest => out_buf, :max_output_size => max_output_size)
+          }.to raise_error(ArgumentError, "`:dest` buffer size (10) must be greater than or equal `:max_output_size` (20)")
+        end
+      end
+    end
+  end
+end

data/spec/lz4_raw_decompress_spec.rb

@@ -0,0 +1,129 @@
+require './spec/helper'
+
+describe "LZ4::Raw.decompress" do
+  context "give compressed empty text" do
+    decompressed, size = LZ4::Raw.decompress([0x00].pack("C*"), 0)
+
+    it "should be decompressed to length zero" do
+      expect(size).to eql(0)
+      expect(decompressed.size).to eql(0)
+      expect(decompressed).to eql("")
+    end
+  end
+
+  context "give compressed text '#{compressed = [0x1a, 0x61, 0x01, 0x00, 0x50, 0x61, 0x61, 0x61, 0x61, 0x61]}'" do
+    expected = "aaaaaaaaaaaaaaaaaaaa"
+
+    context "with enough max_output_size" do
+      decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), 30)
+
+      it "should be decompressed to length #{expected.size}" do
+        expect(size).to eql(expected.size)
+        expect(decompressed.size).to eql(expected.size)
+      end
+
+      it "should be decompressed into '#{expected}'" do
+        expect(decompressed).to eql(expected)
+      end
+    end
+
+    context "with poor max_output_size" do
+      it "should be thrown LZ4Error" do
+        expect {
+          decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), 10)
+        }.to raise_error LZ4Error, "decompression failed"
+      end
+    end
+
+    context "with input_size" do
+      context "#{compressed.length}, which is equal to compressed text length" do
+        decompressed, size = LZ4::Raw.decompress(compressed.pack("C*") + "     ", 30, :input_size => compressed.size)
+
+        it "should be decompressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+          expect(decompressed.size).to eql(expected.size)
+        end
+
+        it "should be decompressed into '#{expected}'" do
+          expect(decompressed).to eql(expected)
+        end
+      end
+
+      context "20 which is greater than compressed text length (#{compressed.length})" do
+        input_size = 20
+
+        it "should be thrown ArgumentError" do
+          expect {
+            decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), 30, :input_size => input_size)
+          }.to raise_error ArgumentError, "`:input_size` (20) must be less than or equal `source.length` (#{compressed.length})"
+        end
+      end
+    end
+
+    context "with output buffer" do
+      context "enough buffer size: 30" do
+        out_buf_size = 30
+        out_buf = " " * out_buf_size
+
+        decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), out_buf_size, :dest => out_buf)
+
+        it "should be decompressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+        end
+
+        it "should be unchanged output buffer size" do
+          expect(decompressed.size).to eql(out_buf_size)
+        end
+
+        it "should be decompressed into '#{expected}'" do
+          expect(decompressed[0, size]).to eql(expected)
+        end
+
+        it "should be used output buffer" do
+          expect(decompressed).to eql(out_buf)
+        end
+      end
+
+      context "poor buffer size: 19" do
+        out_buf_size = 19
+        out_buf = " " * out_buf_size
+
+        it "should be thrown LZ4Error" do
+          expect {
+            decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), out_buf_size, :dest => out_buf)
+          }.to raise_error LZ4Error, "decompression failed"
+        end
+      end
+    end
+
+    context "with output buffer and max_output_size" do
+      context "when size of output buffer: 30, which is greater than max_output_size: 20" do
+        out_buf_size = 30
+        max_output_size = 20
+        out_buf = " " * out_buf_size
+
+        decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), max_output_size, :dest => out_buf)
+
+        it "should be decompressed to length #{expected.size}" do
+          expect(size).to eql(expected.size)
+        end
+
+        it "should be decompressed into '#{expected}'" do
+          expect(decompressed[0, size]).to eql(expected)
+        end
+      end
+
+      context "when size of output buffer: 10, which is less than max_output_size: 20" do
+        out_buf_size = 10
+        max_output_size = 20
+        out_buf = " " * out_buf_size
+
+        it "should be thrown ArgumentError" do
+          expect {
+            decompressed, size = LZ4::Raw.decompress(compressed.pack("C*"), max_output_size, :dest => out_buf)
+          }.to raise_error ArgumentError, "`:dest` buffer size (10) must be greater than or equal `max_output_size` (20)"
+        end
+      end
+    end
+  end
+end

data/spec/lz4_raw_spec.rb

@@ -0,0 +1,34 @@
+require './spec/helper'
+
+describe "LZ4::Raw compressibility" do
+  context "give 'lz4-ruby.rb' file" do
+    filename = "./lib/lz4-ruby.rb"
+    text = IO.readlines(filename).join("\n")
+
+    compressed, comp_size = LZ4::Raw.compress(text)
+    compressedHC, compHC_size = LZ4::Raw.compressHC(text)
+
+    decompressed, decomp_size = LZ4::Raw.decompress(compressed, text.length)
+    decompressedHC, decompHC_size = LZ4::Raw.decompress(compressedHC, text.length)
+
+    it "should be able to comprese smaller than original text" do
+      expect(comp_size).to be < text.length
+    end
+
+    it "should be able to compressHC smaller than original text" do
+      expect(compHC_size).to be < text.length
+    end
+
+    it "should be able to compressHC smaller than compress" do
+      expect(compHC_size).to be < comp_size
+    end
+
+    it "should be able to decompress from compressed text" do
+      expect(decompressed).to eql(text)
+    end
+    
+    it "should be able to decompress from compressHCed text" do
+      expect(decompressedHC).to eql(text)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lz4-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: java
 authors:
 - KOMIYA Atsushi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-02 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -89,6 +89,7 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - .document
+- CHANGELOG.rdoc
 - Gemfile
 - LICENSE.txt
 - README.rdoc
@@ -113,6 +114,9 @@ files:
 - spec/helper.rb
 - spec/lz4_compressHC_spec.rb
 - spec/lz4_compress_spec.rb
+- spec/lz4_raw_compress_spec.rb
+- spec/lz4_raw_decompress_spec.rb
+- spec/lz4_raw_spec.rb
 - src/main/java/com/headius/jruby/lz4/LZ4Internal.java
 - src/main/java/com/headius/jruby/lz4/LZ4Library.java
 homepage: http://github.com/komiya-atsushi/lz4-ruby
@@ -135,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key:
 specification_version: 4
 summary: Ruby bindings for LZ4 (Extremely Fast Compression algorithm).