seven_zip_ruby_am 1.2.5.1

data/lib/seven_zip_ruby/update_info.rb

@@ -0,0 +1,116 @@
+module SevenZipRuby
+  class UpdateInfo
+    class << self
+      def buffer(name, data, opt={})
+        new(:buffer, opt.merge({ name: name, data: data }))
+      end
+
+      def dir(name, opt={})
+        new(:dir, opt.merge({ name: name }))
+      end
+
+      def file(name, filepath, szw)
+        new(:file, { name: name, filepath: filepath, szw: szw })
+      end
+    end
+
+    def initialize(type, param)
+      @type = type
+      case(type)
+      when :buffer
+        name = param.delete(:name)
+        data = param.delete(:data)
+        initialize_buffer(name, data, param)
+      when :dir
+        name = param.delete(:name)
+        initialize_dir(name, param)
+      when :file
+        initialize_file(param[:name], param[:filepath], param[:szw])
+      end
+    end
+
+    def initialize_buffer(name, data, opt)
+      @index_in_archive = nil
+      @new_data = true
+      @new_properties = true
+      @anti = false
+
+      @path = name
+      @dir = false
+      @data = data
+      @size = data.size
+      @attrib = 0x20
+      @posix_attrib = 0x00
+      time = Time.now
+      @ctime = (opt[:ctime] || time)
+      @atime = (opt[:atime] || time)
+      @mtime = (opt[:mtime] || time)
+      @user = @group = nil
+    end
+
+    def initialize_dir(name, opt)
+      @index_in_archive = nil
+      @new_data = true
+      @new_properties = true
+      @anti = false
+
+      @path = name
+      @dir = true
+      @data = nil
+      @size = 0
+      @attrib = 0x10
+      @posix_attrib = 0x00
+      time = Time.now
+      @ctime = (opt[:ctime] || time)
+      @atime = (opt[:atime] || time)
+      @mtime = (opt[:mtime] || time)
+      @user = @group = nil
+    end
+
+    def initialize_file(name, filepath, szw)
+      @index_in_archive = nil
+      @new_data = true
+      @new_properties = true
+      @anti = false
+
+      @path = name.to_s
+      @dir = false
+      filepath = Pathname(filepath).expand_path
+      @data = filepath.to_s
+      @size = filepath.size
+      @attrib = (szw.get_file_attribute(filepath.to_s) || 0x20)
+      @posix_attrib = 0x00
+      @ctime = filepath.ctime
+      @atime = filepath.atime
+      @mtime = filepath.mtime
+      @user = @group = nil
+    end
+
+
+    attr_reader :index_in_archive, :path, :data, :size, :attrib, :ctime, :atime, :mtime, :posix_attrib, :user, :group
+
+    def buffer?
+      return (@type == :buffer)
+    end
+
+    def directory?
+      return @dir
+    end
+
+    def file?
+      return !(@dir)
+    end
+
+    def new_data?
+      return @new_data
+    end
+
+    def new_properties?
+      return @new_properties
+    end
+
+    def anti?
+      return @anti
+    end
+  end
+end

data/lib/seven_zip_ruby/version.rb

@@ -0,0 +1,3 @@
+module SevenZipRuby
+  VERSION = "1.2.5.1"
+end

data/seven_zip_ruby.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'seven_zip_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "seven_zip_ruby"
+  spec.version       = SevenZipRuby::VERSION
+  spec.authors       = ["Masamitsu MURASE"]
+  spec.email         = ["masamitsu.murase@gmail.com"]
+  spec.description   = %q{SevenZipRuby (seven_zip_ruby) is a ruby gem library to read and write 7zip archives. This gem library calls official 7z.dll internally. This gem is the current code on the github repo as of May 2, 2019 which does not have the <2.4 restriction. }
+  spec.summary       = %q{This is a ruby gem library to read and write 7zip files.}
+  spec.homepage      = "https://github.com/masamitsu-murase/seven_zip_ruby"
+  spec.license       = "LGPL + unRAR"
+
+  spec.files         = `git ls-files`.split($/).select{ |i| !(i.start_with?("pkg") || i.start_with?("resources")) }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  if (RUBY_ENGINE == "rbx")
+    spec.add_development_dependency "rubysl"
+    spec.add_development_dependency "rubysl-singleton"
+    spec.add_development_dependency "rubysl-abbrev"
+    spec.add_development_dependency "rubysl-irb"
+  end
+
+  spec.extensions << "ext/seven_zip_ruby/extconf.rb"
+end

data/spec/seven_zip_ruby_spec.rb

@@ -0,0 +1,702 @@
+require("seven_zip_ruby")
+require_relative("seven_zip_ruby_spec_helper")
+
+describe SevenZipRuby do
+  before(:all) do
+    SevenZipRubySpecHelper.prepare_all
+    # GC.stress = true
+  end
+
+  after(:all) do
+    # GC.stress = false
+    SevenZipRubySpecHelper.cleanup_all
+  end
+
+  before(:each) do
+    @use_native_input_file_stream = SevenZipRuby::SevenZipWriter.use_native_input_file_stream
+    SevenZipRubySpecHelper.prepare_each
+  end
+
+  after(:each) do
+    SevenZipRubySpecHelper.cleanup_each
+    SevenZipRuby::SevenZipWriter.use_native_input_file_stream = @use_native_input_file_stream
+  end
+
+
+  describe SevenZipRuby::SevenZipReader do
+
+    example "get entry information in the archive" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        szr = SevenZipRuby::SevenZipReader.new
+        szr.open(file)
+        entries = szr.entries
+
+        expect(entries.size).to be SevenZipRubySpecHelper::SAMPLE_DATA.size
+
+        SevenZipRubySpecHelper::SAMPLE_DATA.each do |sample|
+          entry = entries.select{ |i| i.path == Pathname(sample[:name]).cleanpath.to_s }
+          expect(entry.size).to be 1
+
+          entry = entry[0]
+          expect(entry.directory?).to be sample[:directory]
+        end
+
+        szr.close
+      end
+    end
+
+    example "get archive information" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.open(file) do |szr|
+          info = szr.archive_property
+
+          expect(info.num_blocks).to be_a Integer
+          expect(info.header_size).to be < file.size
+          expect(info.method).to eq "LZMA"
+          expect(info.phy_size).to be file.size
+          expect(info.solid?).to be true
+        end
+      end
+    end
+
+    example "extract data directly from archive" do
+      SevenZipRuby::SevenZipReader.open_file(SevenZipRubySpecHelper::SEVEN_ZIP_FILE) do |szr|
+        entries = szr.entries
+
+        SevenZipRubySpecHelper::SAMPLE_DATA.each do |sample|
+          entry = entries.find{ |i| i.path == Pathname(sample[:name]).cleanpath.to_s }
+          expect(szr.extract_data(entry.index)).to eq sample[:data]
+        end
+      end
+    end
+
+    example "extract selected data from archive" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.open(file) do |szr|
+          entries = szr.entries.select{ |i| i.file? }
+          expect(szr.extract_data(entries).all?).to eq true
+        end
+      end
+    end
+
+    example "singleton method: extract" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.extract(file, :all, SevenZipRubySpecHelper::EXTRACT_DIR)
+      end
+    end
+
+    example "singleton method: extract_all" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.extract_all(file, SevenZipRubySpecHelper::EXTRACT_DIR)
+      end
+    end
+
+    example "singleton method: verify" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.verify(file)
+      end
+    end
+
+    example "extract archive" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.open(file) do |szr|
+          szr.extract_all(SevenZipRubySpecHelper::EXTRACT_DIR)
+        end
+      end
+
+      Dir.chdir(SevenZipRubySpecHelper::EXTRACT_DIR) do
+        SevenZipRubySpecHelper::SAMPLE_DATA.each do |info|
+          path = Pathname(info[:name])
+          expected_path = Pathname(SevenZipRubySpecHelper::SAMPLE_FILE_DIR) + info[:name]
+          expect(path.mtime.to_i).to eq expected_path.mtime.to_i
+          expect(path.file?).to eq expected_path.file?
+          (expect(File.open(path, "rb", &:read)).to eq info[:data]) if (path.file?)
+        end
+      end
+    end
+
+    example "run in another thread" do
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        szr = nil
+        sample = nil
+        entry = nil
+        th = Thread.new do
+          szr = SevenZipRuby::SevenZipReader.open(file)
+          sample = SevenZipRubySpecHelper::SAMPLE_DATA.sample
+          entry = szr.entries.find{ |i| i.path == Pathname(sample[:name]).cleanpath.to_s }
+        end
+        th.join
+
+        expect(szr.extract_data(entry.index)).to eq sample[:data]
+      end
+    end
+
+    example "test archive" do
+      data = File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb", &:read)
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data)) do |szr|
+        expect(szr.test).to eq true
+      end
+
+      expect(SevenZipRuby::SevenZipReader.verify(StringIO.new(data))).to eq true
+
+      data_org = data[-1]
+      data[-1] = 0x01.chr  # This highly dependes on the current test binary.
+      expect(SevenZipRuby::SevenZipReader.verify(StringIO.new(data))).to eq false
+      data[-1] = data_org
+
+      data[0x27] = 0xEB.chr  # This highly dependes on the current test binary.
+      expected = [ :DataError, :DataError, :DataError, :DataError, :DataError, :DataError, :DataError, true, true, true, true, true ]
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data)) do |szr|
+        expect(szr.test).to eq false
+        expect(szr.verify_detail).to eq expected
+      end
+
+
+      data = File.open(SevenZipRubySpecHelper::SEVEN_ZIP_PASSWORD_FILE, "rb", &:read)
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data), { password: SevenZipRubySpecHelper::SEVEN_ZIP_PASSWORD }) do |szr|
+        expect(szr.verify).to eq true
+      end
+
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data), { password: "wrong password" }) do |szr|
+        expect(szr.verify).to eq false
+      end
+
+      expected = [ :DataError, :DataError, :DataError, :DataError, :DataError, :DataError, :DataError, true, true, true, true, true ]
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data), { password: "wrong password" }) do |szr|
+        expect(szr.verify_detail).to eq expected
+      end
+    end
+
+    example "run in multi threads" do
+      s = StringIO.new
+      SevenZipRuby::SevenZipWriter.open(s) do |szw|
+        szw.add_data(SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA, "data.bin")
+      end
+      data = s.string
+
+      th_list = []
+      100.times do
+        th = Thread.new do
+          stream = StringIO.new(data)
+          SevenZipRuby::SevenZipReader.open(stream) do |szr|
+            szr.extract_data(0)
+          end
+        end
+        th_list.push(th)
+      end
+      th_list.each(&:join)
+    end
+
+
+    describe "error handling" do
+
+      example "throw in method" do
+        [ :read, :seek ].each do |method|
+          catch do |tag|
+            File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+              file.define_singleton_method(method) do |*args|
+                throw tag
+              end
+              expect{ SevenZipRuby::SevenZipReader.open(file) }.to raise_error(ArgumentError)
+            end
+          end
+        end
+      end
+
+      example "invalid index" do
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+          SevenZipRuby::SevenZipReader.open(file) do |szr|
+            expect{ szr.extract_data(nil) }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      example "invalid index for entry" do
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+          SevenZipRuby::SevenZipReader.open(file) do |szr|
+            expect{ szr.entry("a") }.to raise_error(TypeError)
+          end
+        end
+      end
+
+      example "invalid password" do
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_PASSWORD_FILE, "rb") do |file|
+          expect{ SevenZipRuby::Reader.open(file){ |szr| szr.extract_data(1) } }.to raise_error(StandardError)
+        end
+
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_PASSWORD_FILE, "rb") do |file|
+          expect{ SevenZipRuby::Reader.open(file, password: "a"){ |szr| szr.extract_data(1) } }.to raise_error(SevenZipRuby::InvalidArchive)
+        end
+
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_PASSWORD_FILE, "rb") do |file|
+          expect{ SevenZipRuby::Reader.open(file, password: :InvalidType){ |szr| szr.extract_data(1) } }.to raise_error(SevenZipRuby::InvalidArchive)
+        end
+      end
+
+      example "raise error in open" do
+        error = StandardError.new
+
+        [ :read, :seek ].each do |method|
+          file = File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb")
+          file.define_singleton_method(method) do |*args|
+            raise error
+          end
+          expect{ SevenZipRuby::SevenZipReader.open(file) }.to raise_error(error)
+          file.close
+        end
+      end
+
+      example "raise error after open" do
+        error = StandardError.new
+
+        [ :read, :seek ].each do |method|
+          file = File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb")
+
+          szr = nil
+          expect{ szr = SevenZipRuby::SevenZipReader.open(file) }.not_to raise_error
+
+          file.define_singleton_method(method) do |*args|
+            raise error
+          end
+          expect{ szr.extract_data(1) }.to raise_error(error)
+
+          file.close
+        end
+      end
+
+      example "try to extract/entries before open" do
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+          szr = SevenZipRuby::SevenZipReader.new
+          expect{ szr.extract_data(1) }.to raise_error(SevenZipRuby::InvalidOperation)
+          expect{ szr.entry(1) }.to raise_error(SevenZipRuby::InvalidOperation)
+        end
+      end
+
+      example "try to extract/entries after close" do
+        File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+          szr = SevenZipRuby::SevenZipReader.open(file)
+          szr.close
+
+          expect{ szr.extract_data(1) }.to raise_error(SevenZipRuby::InvalidOperation)
+          expect{ szr.entry(1) }.to raise_error(SevenZipRuby::InvalidOperation)
+        end
+      end
+
+      example "kill thread" do
+        th = Thread.start do
+          File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+            class << file
+              alias orig_read read
+
+              def read(*args)
+                sleep 2
+                return orig_read(*args)
+              end
+            end
+
+            SevenZipRuby::SevenZipReader.open(file)
+          end
+        end
+
+        sleep 1
+        expect{ th.kill }.not_to raise_error  # Thread can be killed.
+      end
+
+      example "clone and dup cannot be called." do
+        expect{ SevenZipRuby::SevenZipReader.new.clone }.to raise_error(NoMethodError)
+        expect{ SevenZipRuby::SevenZipReader.new.dup }.to raise_error(NoMethodError)
+      end
+
+    end
+
+  end
+
+
+  describe SevenZipRuby::SevenZipWriter do
+
+    example "compress without block" do
+      output = StringIO.new("")
+      szw = SevenZipRuby::SevenZipWriter.new
+      szw.open(output)
+      szw.add_data("This is hoge.txt content.", "hoge.txt")
+      szw.add_data("This is hoge2.txt content.", "hoge2.txt")
+      szw.mkdir("hoge/hoge/hoge")
+      szw.compress
+      szw.close
+
+      output.rewind
+      expect(SevenZipRuby::SevenZipReader.verify(output)).to eq true
+    end
+
+    example "compress" do
+      output = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output) do |szw|
+        szw.add_data("This is hoge.txt content.", "hoge.txt")
+        szw.add_data("This is hoge2.txt content.", "hoge2.txt")
+        szw.mkdir("hoge/hoge/hoge")
+        szw.compress
+      end
+
+      output.rewind
+      expect(SevenZipRuby::SevenZipReader.verify(output)).to eq true
+    end
+
+    example "open_file" do
+      FileUtils.mkpath(SevenZipRubySpecHelper::EXTRACT_DIR)
+      Dir.chdir(SevenZipRubySpecHelper::EXTRACT_DIR) do
+        filename = "hoge.7z"
+
+        SevenZipRuby::SevenZipWriter.open_file(filename) do |szw|
+          szw.add_data("This is a sample.", "hoge.txt")
+        end
+
+        File.open(filename, "rb") do |f|
+          expect(SevenZipRuby::SevenZipReader.verify(f)).to eq true
+        end
+      end
+    end
+
+    example "compress local file" do
+      Dir.chdir(SevenZipRubySpecHelper::SAMPLE_FILE_DIR) do
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          data = SevenZipRubySpecHelper::SAMPLE_DATA[0]
+          szw.add_file(data[:name])
+        end
+
+        output.rewind
+        SevenZipRuby::SevenZipReader.open(output) do |szr|
+          data = SevenZipRubySpecHelper::SAMPLE_DATA[0]
+          expect(szr.entries[0].path.to_s).to eq data[:name]
+          expect(szr.extract_data(0)).to eq data[:data]
+        end
+      end
+    end
+
+    example "set password" do
+      sample_data = "Sample Data"
+      sample_password = "sample password"
+
+      output = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output, { password: sample_password }) do |szw|
+        szw.add_data(sample_data, "hoge.txt")
+      end
+
+      output.rewind
+      SevenZipRuby::SevenZipReader.open(output, { password: sample_password }) do |szr|
+        expect(szr.extract_data(0)).to eq sample_data
+      end
+
+      output.rewind
+      expect{
+        SevenZipRuby::SevenZipReader.open(output, { password: "invalid password" }) do |szr|
+          szr.extract_data(0)
+        end
+      }.to raise_error(SevenZipRuby::InvalidArchive)
+
+
+      output = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output, { password: sample_password.to_sym }) do |szw|
+        szw.add_data(sample_data, "hoge.txt")
+      end
+
+      output.rewind
+      SevenZipRuby::SevenZipReader.open(output, { password: sample_password }) do |szr|
+        expect(szr.extract_data(0)).to eq sample_data
+      end
+    end
+
+    example "create a sfx archive" do
+      time = Time.now
+
+      output = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output) do |szw|
+        szw.add_data("hogehoge", "hoge.txt", ctime: time, atime: time, mtime: time)
+      end
+
+      output1 = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output1, sfx: true) do |szw|
+        szw.add_data("hogehoge", "hoge.txt", ctime: time, atime: time, mtime: time)
+      end
+
+      output2 = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output2, sfx: :gui) do |szw|
+        szw.add_data("hogehoge", "hoge.txt", ctime: time, atime: time, mtime: time)
+      end
+
+      output3 = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output3, sfx: :console) do |szw|
+        szw.add_data("hogehoge", "hoge.txt", ctime: time, atime: time, mtime: time)
+      end
+
+      gui = File.open(SevenZipRuby::SevenZipWriter::SFX_FILE_LIST[:gui], "rb", &:read)
+      console = File.open(SevenZipRuby::SevenZipWriter::SFX_FILE_LIST[:console], "rb", &:read)
+
+      expect(output1.string).to eq gui + output.string
+      expect(output2.string).to eq gui + output.string
+      expect(output3.string).to eq console + output.string
+    end
+
+    [ true, false ].each do |use_native_input_file_stream|
+      example "add_directory: use_native_input_file_stream=#{use_native_input_file_stream}" do
+        SevenZipRuby::SevenZipWriter.use_native_input_file_stream = use_native_input_file_stream
+
+        Dir.chdir(SevenZipRubySpecHelper::SAMPLE_FILE_DIR) do
+          output = StringIO.new("")
+          SevenZipRuby::SevenZipWriter.open(output) do |szw|
+            Pathname.glob("*", File::FNM_DOTMATCH) do |path|
+              basename = path.basename.to_s
+              next if (basename == "." || basename == "..")
+
+              if (path.file?)
+                szw.add_file(path)
+              else
+                szw.add_directory(path)
+              end
+            end
+          end
+
+          output.rewind
+          SevenZipRuby::SevenZipReader.open(output) do |szr|
+            entries = szr.entries
+            expect(entries.size).to eq SevenZipRubySpecHelper::SAMPLE_DATA.size
+
+            entries.each do |entry|
+              entry_in_sample = SevenZipRubySpecHelper::SAMPLE_DATA.find{ |i| i[:name] == entry.path.to_s }
+              local_entry = Pathname(File.join(SevenZipRubySpecHelper::SAMPLE_FILE_DIR, entry_in_sample[:name]))
+              if (entry_in_sample[:directory])
+                expect(entry.directory?).to eq true
+              else
+                expect(szr.extract_data(entry)).to eq File.open(entry_in_sample[:name], "rb", &:read)
+              end
+              expect(entry.mtime.to_i).to eq local_entry.mtime.to_i
+            end
+          end
+        end
+      end
+
+      example "add_directory singleton version: use_native_input_file_stream=#{use_native_input_file_stream}" do
+        SevenZipRuby::SevenZipWriter.use_native_input_file_stream = use_native_input_file_stream
+
+        dir = File.join(SevenZipRubySpecHelper::SAMPLE_FILE_DIR, "..")
+        dirname = File.basename(SevenZipRubySpecHelper::SAMPLE_FILE_DIR)
+        Dir.chdir(dir) do
+          output = StringIO.new("")
+          SevenZipRuby::SevenZipWriter.add_directory(output, dirname)
+
+          output2 = StringIO.new("")
+          SevenZipRuby::SevenZipWriter.open(output2) do |szr|
+            szr.add_directory(dirname)
+          end
+
+          expect(output.string).to eq output2.string
+        end
+      end
+    end  # use_native_input_file_stream
+
+    example "use as option" do
+      output = StringIO.new("")
+      SevenZipRuby::SevenZipWriter.open(output) do |szw|
+        szw.add_directory(SevenZipRubySpecHelper::SAMPLE_FILE_DIR, as: "test/dir")
+      end
+
+      output.rewind
+      SevenZipRuby::SevenZipReader.open(output) do |szr|
+        base_dir = Pathname(SevenZipRubySpecHelper::SAMPLE_FILE_DIR)
+        entries = szr.entries
+        files = Pathname.glob(base_dir.to_s + "/**/*", File::FNM_DOTMATCH) + [ base_dir ]
+        files = files.select{ |i| i.basename.to_s != "." && i.basename.to_s != ".." }
+
+        expect(entries.size).to eq files.size
+
+        expect(entries.all?{ |i| i.path.start_with?("test/dir") }).to eq true
+
+        entries.each do |entry|
+          file = files.find do |i|
+            i.relative_path_from(base_dir) == Pathname(entry.path).relative_path_from(Pathname("test/dir"))
+          end
+          expect(file.directory?).to eq entry.directory?
+        end
+      end
+    end
+
+    example "use various methods" do
+      [ "COPY", "DEFLATE", "LZMA", "LZMA2", "BZIP2", "PPMd" ].each do |type|
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          szw.method = type
+          szw.add_data(SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA, "hoge.txt")
+        end
+
+        SevenZipRuby::SevenZipReader.open(StringIO.new(output.string)) do |szr|
+          expect(szr.extract_data(0)).to eq SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+        end
+      end
+    end
+
+    example "set compression level" do
+      size = [ 0, 1, 3, 5, 7, 9 ].map do |level|
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          szw.level = level
+          data = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+          time = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA_TIMESTAMP
+          szw.add_data(data, "hoge1.txt", mtime: time)
+          szw.add_data(data + data.slice(1 .. -1), "hoge2.txt", mtime: time)
+          szw.add_data(data + data.reverse + data.slice(1 .. -1), "hoge3.txt", mtime: time)
+        end
+        next output.string.size
+      end
+      size.each_cons(2) do |large, small|
+        expect(large - small >= 0).to eq true
+      end
+    end
+
+    example "set solid" do
+      size = [ false, true ].map do |solid|
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          szw.solid = solid
+          data = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+          szw.add_data(data, "hoge1.txt")
+          szw.add_data(data + data.slice(1 .. -1), "hoge2.txt")
+        end
+        next output.string.size
+      end
+      expect(size.sort.reverse).to eq size
+    end
+
+    example "set header_compression" do
+      size = [ false, true ].map do |header_compression|
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          szw.header_compression = header_compression
+          data = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+          10.times do |i|
+            szw.add_data(data, "hoge#{i}.txt")
+          end
+        end
+        next output.string.size
+      end
+      expect(size.sort.reverse).to eq size
+    end
+
+    example "run in multi threads" do
+      th_list = []
+      100.times do
+        th = Thread.new do
+          stream = StringIO.new
+          SevenZipRuby::SevenZipWriter.open(stream) do |szw|
+            data = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+            szw.add_data(data, "hoge.dat")
+          end
+        end
+        th_list.push(th)
+      end
+      th_list.each(&:join)
+    end
+
+    if (SevenZipRubySpecHelper.processor_count && SevenZipRubySpecHelper.processor_count > 1)
+      example "set multi_thread" do
+        time = [ false, true ].map do |multi_thread|
+          output = StringIO.new("")
+          start = nil
+          SevenZipRuby::SevenZipWriter.open(output) do |szw|
+            szw.method = "BZIP2"  # BZIP2 uses multi threads.
+            szw.multi_thread = multi_thread
+            data = SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA
+            szw.add_data(data * 10, "hoge.txt")
+            start = Time.now
+          end
+          next Time.now - start
+        end
+        expect(time.sort.reverse).to eq time
+      end
+    end
+
+
+    describe "error handling" do
+
+      example "raise error in update" do
+        error = StandardError.new
+
+        [ :write, :seek ].each do |method|
+          output = StringIO.new("")
+          output.define_singleton_method(method) do |*args|
+            raise error
+          end
+          expect{ SevenZipRuby::SevenZipWriter.open(output).compress }.to raise_error(error)
+        end
+      end
+
+      example "invalid method" do
+        expect{ SevenZipRuby::SevenZipWriter.open(StringIO.new("")).method = "Unknown" }.to raise_error(ArgumentError)
+      end
+
+      example "invalid level" do
+        expect{ SevenZipRuby::SevenZipWriter.open(StringIO.new("")).level = 2 }.to raise_error(ArgumentError)
+      end
+
+      example "add_data/mkdir/compress/close before open" do
+        szw = SevenZipRuby::SevenZipWriter.new
+        expect{ szw.add_data("This is hoge.txt content.", "hoge.txt") }.to raise_error(SevenZipRuby::InvalidOperation)
+
+        szw = SevenZipRuby::SevenZipWriter.new
+        expect{ szw.mkdir("hoge/hoge") }.to raise_error(SevenZipRuby::InvalidOperation)
+
+        szw = SevenZipRuby::SevenZipWriter.new
+        expect{ szw.compress }.to raise_error(SevenZipRuby::InvalidOperation)
+
+        szw = SevenZipRuby::SevenZipWriter.new
+        expect{ szw.close }.to raise_error(SevenZipRuby::InvalidOperation)
+      end
+
+      example "add_data after close" do
+        output = StringIO.new("")
+        szw = SevenZipRuby::SevenZipWriter.new
+        szw.open(output)
+        szw.close
+        expect{ szw.add_data("This is hoge.txt content.", "hoge.txt") }.to raise_error(SevenZipRuby::InvalidOperation)
+      end
+
+      example "clone and dup cannot be called." do
+        expect{ SevenZipRuby::SevenZipWriter.new.clone }.to raise_error(NoMethodError)
+        expect{ SevenZipRuby::SevenZipWriter.new.dup }.to raise_error(NoMethodError)
+      end
+
+      if (false && RUBY_ENGINE == "ruby")
+        # It seems that Rubinius has the different way to handle error.
+        # Therefore, it sometimes fails to kill SevenZipRuby thread.
+        example "kill thread" do
+          [ "LZMA", "PPMd", "BZIP2" ].each do |method|
+            prc = lambda do
+              output = StringIO.new("")
+              SevenZipRuby::SevenZipWriter.open(output) do |szw|
+                szw.method = method
+                szw.level = 9
+                szw.multi_thread = true
+                szw.add_data(SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA * 3, "hoge.txt")
+              end
+            end
+
+            start = Time.now
+            th = Thread.start{ prc.call }
+            th.join
+            diff = Time.now - start
+
+            20.times do
+              kill_time = rand * diff
+              th = Thread.start{ prc.call }
+              sleep(kill_time)
+              expect{ th.kill }.not_to raise_error   # Thread can be killed.
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end
+