seven_zip_ruby 1.0.0-x64-mingw32

data/lib/seven_zip_ruby/seven_zip_writer.rb

@@ -0,0 +1,143 @@
+require("stringio")
+
+module SevenZipRuby
+  class SevenZipWriter
+    PATH_ENCODING = Encoding::UTF_8
+
+    class << self
+      def open(stream, param = {}, &block)
+        szw = self.new
+        szw.open(stream, param)
+        if (block)
+          block.call(szw)
+          szw.compress
+          szw.close
+        else
+          szw
+        end
+      end
+
+      def add_directory(stream, dir, param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szw|
+          szw.add_directory(dir, param)
+        end
+      end
+      alias add_dir add_directory
+
+      def add_file(stream, filename, param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szw|
+          szw.add_file(filename, param)
+        end
+      end
+    end
+
+    def open(stream, param = {})
+      stream.set_encoding(Encoding::ASCII_8BIT)
+      open_impl(stream, param)
+      return self
+    end
+
+    def compress
+      compress_impl(compress_proc)
+      return self
+    end
+
+    def add_file(filename, opt={})
+      path = Pathname(filename)
+      check_option(opt, [ :as ])
+
+      if (opt[:as])
+        filename = Pathname(opt[:as]).cleanpath
+        raise ArgumentError.new(":as should contain valid pathname. #{opt[:as]}") if (filename.to_s.empty?)
+        raise ArgumentError.new(":as should be relative. #{opt[:as]}") if (filename.absolute?)
+      else
+        raise ArgumentError.new("filename should be relative. #{filename}") if (path.absolute?)
+        filename = path.cleanpath
+      end
+      add_item(UpdateInfo.file(filename.to_s.encode(PATH_ENCODING), path, self))
+      return self
+    end
+
+    def add_data(data, filename, opt={})
+      path = Pathname(filename)
+      raise ArgumentError.new("filename should be relative") if (path.absolute?)
+      check_option(opt, [ :ctime, :atime, :mtime ])
+
+      name = path.cleanpath.to_s.encode(PATH_ENCODING)
+      add_item(UpdateInfo.buffer(name, data, opt))
+      return self
+    end
+
+    def add_directory(directory, opt={})
+      directory = Pathname(directory).cleanpath
+      check_option(opt, [ :as ])
+
+      if (opt[:as])
+        base_dir = Pathname(opt[:as]).cleanpath
+        raise ArgumentError.new(":as should contain valid pathname. #{opt[:as]}") if (base_dir.to_s.empty?)
+        raise ArgumentError.new(":as should be relative. #{opt[:as]}") if (base_dir.absolute?)
+
+        mkdir(base_dir, { ctime: directory.ctime, atime: directory.atime, mtime: directory.mtime })
+      else
+        raise ArgumentError.new("directory should be relative #{directory}") if (directory.absolute?)
+
+        mkdir(directory, { ctime: directory.ctime, atime: directory.atime, mtime: directory.mtime })
+      end
+
+      Pathname.glob(directory.join("**", "*").to_s) do |entry|
+        name = (base_dir + entry.relative_path_from(directory)).cleanpath if (base_dir)
+
+        if (entry.file?)
+          add_file(entry, as: name)
+        elsif (entry.directory?)
+          mkdir(name || entry, { ctime: entry.ctime, atime: entry.atime, mtime: entry.mtime })
+        else
+          raise "#{entry} is invalid entry"
+        end
+      end
+
+      return self
+    end
+    alias add_dir add_directory
+
+    def mkdir(directory_name, opt={})
+      path = Pathname(directory_name)
+      raise ArgumentError.new("directory_name should be relative") if (path.absolute?)
+      check_option(opt, [ :ctime, :atime, :mtime ])
+
+      name = path.cleanpath.to_s.encode(PATH_ENCODING)
+      add_item(UpdateInfo.dir(name, opt))
+      return self
+    end
+
+
+    def check_option(opt, keys)
+      invalid_keys = opt.keys - keys
+      raise ArgumentError.new("invalid option: " + invalid_keys.join(", ")) unless (invalid_keys.empty?)
+    end
+
+
+    def compress_proc
+      return Proc.new do |type, info|
+        case(type)
+        when :stream
+          if (info.buffer?)
+            next StringIO.new(info.data)
+          elsif (info.file?)
+            next File.open(info.data, "rb")
+          else
+            next nil
+          end
+        when :result
+          info[:stream].close if (info[:stream])
+        end
+      end
+    end
+    private :compress_proc
+  end
+
+
+  Writer = SevenZipWriter
+end

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.0.0"
+end

data/seven_zip_ruby.gemspec

@@ -0,0 +1,28 @@
+# 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 is a gem library to read and write 7zip archives. This gem library calls official 7z.dll internally.}
+  spec.summary       = %q{This is a gem library to read and write 7-Zip 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") || i.start_with?("ext")) } + Dir.glob("lib/**/*.so").to_a
+  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.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+#  spec.extensions << "ext/seven_zip_ruby/extconf.rb"
+
+  spec.platform = Gem::Platform::CURRENT
+end

data/spec/seven_zip_ruby_spec.rb

@@ -0,0 +1,490 @@
+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
+    SevenZipRubySpecHelper.prepare_each
+  end
+
+  after(:each) do
+    SevenZipRubySpecHelper.cleanup_each
+  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 }
+          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
+      File.open(SevenZipRubySpecHelper::SEVEN_ZIP_FILE, "rb") do |file|
+        SevenZipRuby::SevenZipReader.open(file) do |szr|
+          entries = szr.entries
+
+          SevenZipRubySpecHelper::SAMPLE_DATA.each do |sample|
+            entry = entries.find{ |i| i.path == Pathname(sample[:name]).cleanpath }
+            expect(szr.extract_data(entry.index)).to eq sample[:data]
+          end
+        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 "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 }
+        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[0x27] = 0xEB.chr  # This highly dependes on the current test binary.
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data)) do |szr|
+        expect(szr.test).to eq false
+        expect(szr.verify_detail).to eq [ :DataError, :DataError, :DataError, true, true, true ]
+      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
+
+      SevenZipRuby::SevenZipReader.open(StringIO.new(data), { password: "wrong password" }) do |szr|
+        expect(szr.verify_detail).to eq [ :DataError, :DataError, :DataError, true, true, true ]
+      end
+    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 "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.
+
+
+        th = Thread.start do
+          SevenZipRuby::SevenZipWriter.open(output) do |szw|
+            szw.method = "BZIP2"
+            szw.level = 9
+            szw.multi_thread = false
+            szw.add_data(SevenZipRubySpecHelper::SAMPLE_LARGE_RANDOM_DATA * 2, "hoge.txt")
+          end
+        end
+
+        sleep 0.1  # Highly dependes on CPU speed...
+        expect{ th.kill }.not_to raise_error # Thread can be killed.
+      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.close
+    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")
+      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 "add_directory" do
+      Dir.chdir(SevenZipRubySpecHelper::SAMPLE_FILE_DIR) do
+        output = StringIO.new("")
+        SevenZipRuby::SevenZipWriter.open(output) do |szw|
+          Pathname.glob("*") do |path|
+            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" do
+      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
+
+    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 + "/**/*") +[ base_dir ]
+
+        expect(entries.size).to eq files.size
+
+        expect(entries.all?{ |i| i.path.to_s.start_with?("test/dir") }).to eq true
+
+        entries.each do |entry|
+          file = files.find do |i|
+            i.relative_path_from(base_dir) == 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
+
+    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
+      end
+
+      example "invalid level" do
+        expect{ SevenZipRuby::SevenZipWriter.open(StringIO.new("")).level = 2 }.to raise_error
+      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
+
+    end
+
+  end
+
+end
+