lz4-ruby 0.2.0-x86-mingw32 → 0.3.0-x86-mingw32

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lz4-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: x86-mingw32
 authors: 
 - KOMIYA Atsushi
@@ -9,55 +9,55 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-12-02 00:00:00 Z
+date: 2014-03-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - &id003 
       - ">="
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  name: rspec
-  prerelease: false
-  requirement: *id001
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  name: rdoc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         version: "3.12"
   type: :development
-  name: rdoc
-  prerelease: false
-  requirement: *id002
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - *id003
   type: :development
-  name: bundler
-  prerelease: false
-  requirement: *id004
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  name: jeweler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         version: 1.8.3
   type: :development
-  name: jeweler
-  prerelease: false
-  requirement: *id005
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
     requirements: 
     - *id003
   type: :development
-  name: rake-compiler
-  prerelease: false
-  requirement: *id006
+  version_requirements: *id006
 description: Ruby bindings for LZ4. LZ4 is a very fast lossless compression algorithm.
 email: komiya.atsushi@gmail.com
 executables: []
@@ -69,6 +69,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
+- CHANGELOG.rdoc
 - Gemfile
 - LICENSE.txt
 - README.rdoc
@@ -94,6 +95,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