adsp 1.0.0

data/test/option.rb

@@ -0,0 +1,66 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require "ocg"
+require "adsp/option"
+
+require_relative "validation"
+
+module ADSP
+  module Test
+    module Option
+      private_class_method def self.get_common_invalid_options(buffer_length_names, &block)
+        Validation::INVALID_HASHES.each(&block)
+
+        buffer_length_names.each do |name|
+          (Validation::INVALID_NOT_NEGATIVE_INTEGERS - [nil]).each do |invalid_integer|
+            yield({ name => invalid_integer })
+          end
+        end
+      end
+
+      def self.get_invalid_compressor_options(buffer_length_names, &block)
+        get_common_invalid_options buffer_length_names, &block
+      end
+
+      def self.get_invalid_decompressor_options(buffer_length_names, &block)
+        get_common_invalid_options buffer_length_names, &block
+      end
+
+      # -----
+
+      # "0" means default buffer length.
+      BUFFER_LENGTHS = [
+        0,
+        2
+      ]
+      .freeze
+
+      BOOLS = [
+        true,
+        false
+      ]
+      .freeze
+
+      private_class_method def self.get_buffer_length_option_generator(buffer_length_names)
+        OCG.new(
+          buffer_length_names.to_h { |name| [name, self::BUFFER_LENGTHS] }
+        )
+      end
+
+      def self.get_compressor_options_generator(buffer_length_names)
+        get_buffer_length_option_generator buffer_length_names
+      end
+
+      def self.get_compatible_decompressor_options(compressor_options, buffer_length_name_mapping, &_block)
+        decompressor_options = {}
+
+        buffer_length_name_mapping.each do |compressor_name, decompressor_name|
+          decompressor_options[decompressor_name] = compressor_options[compressor_name]
+        end
+
+        yield decompressor_options
+      end
+    end
+  end
+end

data/test/stream/abstract.rb

@@ -0,0 +1,125 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require "fcntl"
+require "stringio"
+
+require_relative "../common"
+require_relative "../minitest"
+require_relative "../validation"
+
+module ADSP
+  module Test
+    module Stream
+      class Abstract < Minitest::Test
+        SOURCE_PATH = Common::SOURCE_PATH
+
+        def test_invalid_initialize
+          (Validation::INVALID_STRINGS - [nil] + Validation::INVALID_ENCODINGS).each do |invalid_encoding|
+            assert_raises ValidateError do
+              target.new ::StringIO.new, {}, :external_encoding => invalid_encoding
+            end
+
+            assert_raises ValidateError do
+              target.new ::StringIO.new, {}, :internal_encoding => invalid_encoding
+            end
+          end
+
+          (Validation::INVALID_HASHES - [nil]).each do |invalid_hash|
+            assert_raises ValidateError do
+              target.new ::StringIO.new, {}, :transcode_options => invalid_hash
+            end
+          end
+        end
+
+        def test_invalid_set_encoding
+          instance = target.new ::StringIO.new
+
+          (Validation::INVALID_STRINGS - [nil] + Validation::INVALID_ENCODINGS).each do |invalid_encoding|
+            assert_raises ValidateError do
+              instance.set_encoding invalid_encoding
+            end
+
+            assert_raises ValidateError do
+              instance.set_encoding ::Encoding::BINARY, invalid_encoding
+            end
+          end
+
+          Validation::INVALID_ENCODINGS.each do |invalid_encoding|
+            assert_raises ValidateError do
+              instance.set_encoding "#{::Encoding::BINARY}:#{invalid_encoding}"
+            end
+
+            assert_raises ValidateError do
+              instance.set_encoding "#{invalid_encoding}:#{::Encoding::BINARY}"
+            end
+          end
+
+          (Validation::INVALID_HASHES - [nil]).each do |invalid_hash|
+            assert_raises ValidateError do
+              instance.set_encoding ::Encoding::BINARY, ::Encoding::BINARY, invalid_hash
+            end
+
+            assert_raises ValidateError do
+              instance.set_encoding "#{::Encoding::BINARY}:#{::Encoding::BINARY}", invalid_hash
+            end
+          end
+        end
+
+        def test_to_io
+          instance = target.new ::StringIO.new
+          assert_equal instance, instance.to_io
+        end
+
+        def test_io_delegates
+          ::File.open SOURCE_PATH, "wb+" do |file|
+            instance = target.new file
+
+            instance.autoclose = true
+            assert_predicate instance, :autoclose?
+
+            instance.binmode
+            assert_predicate instance, :binmode
+
+            instance.close_on_exec = true
+            assert_predicate instance, :close_on_exec?
+
+            # Fcntl is not available on windows.
+            if Fcntl.const_defined? :F_GETFL
+              stats = instance.fcntl Fcntl::F_GETFL, 0
+              refute_nil stats
+            end
+
+            instance.fdatasync
+
+            fd = instance.fileno
+            refute_nil fd
+
+            refute_predicate instance, :isatty
+            assert_nil instance.pid
+
+            instance.sync = true
+            assert_predicate instance, :sync
+
+            refute_nil instance.to_i
+            refute_predicate instance, :tty?
+          end
+        end
+
+        def test_stat
+          instance = target.new $stdout
+
+          refute_predicate instance.stat, :file?
+          refute_predicate instance.stat, :pipe?
+          refute_predicate instance.stat, :socket?
+        end
+
+        # -----
+
+        protected def target
+          self.class::Target
+        end
+      end
+    end
+  end
+end

data/test/stream/minitar.test.rb

@@ -0,0 +1,50 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require "minitar"
+
+require_relative "../common"
+require_relative "../minitest"
+require_relative "../mock/stream/reader"
+require_relative "../mock/stream/writer"
+
+module ADSP
+  module Test
+    module Stream
+      class MinitarTest < Minitest::Test
+        Reader = Mock::Stream::Reader
+        Writer = Mock::Stream::Writer
+
+        ARCHIVE_PATH = Common::ARCHIVE_PATH
+        LARGE_TEXTS  = Common::LARGE_TEXTS
+
+        def test_tar
+          Common.parallel LARGE_TEXTS do |text, worker_index|
+            archive_path = Common.get_path ARCHIVE_PATH, worker_index
+
+            Writer.open archive_path do |writer|
+              Minitar::Writer.open writer do |tar|
+                tar.add_file_simple "file", :data => text
+              end
+            end
+
+            Reader.open archive_path do |reader|
+              Minitar::Reader.open reader do |tar|
+                tar.each_entry do |entry|
+                  assert_equal "file", entry.name
+
+                  decompressed_text = entry.read
+                  decompressed_text.force_encoding text.encoding
+
+                  assert_equal text, decompressed_text
+                end
+              end
+            end
+          end
+        end
+      end
+
+      Minitest << MinitarTest
+    end
+  end
+end

data/test/stream/raw/abstract.rb

@@ -0,0 +1,45 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require_relative "../../minitest"
+require_relative "../../validation"
+
+module ADSP
+  module Test
+    module Stream
+      module Raw
+        class Abstract < Minitest::Test
+          NOOP_PROC = Validation::NOOP_PROC
+
+          def test_invalid_flush
+            instance = target.new
+
+            assert_raises ValidateError do
+              instance.flush
+            end
+
+            instance.close(&NOOP_PROC)
+
+            assert_raises UsedAfterCloseError do
+              instance.flush(&NOOP_PROC)
+            end
+          end
+
+          def test_invalid_close
+            instance = target.new
+
+            assert_raises ValidateError do
+              instance.close
+            end
+          end
+
+          # -----
+
+          protected def target
+            self.class::Target
+          end
+        end
+      end
+    end
+  end
+end

data/test/stream/raw/compressor.test.rb

@@ -0,0 +1,166 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require_relative "abstract"
+require_relative "../../common"
+require_relative "../../minitest"
+require_relative "../../mock/stream/raw/compressor"
+require_relative "../../mock/string"
+require_relative "../../option"
+require_relative "../../validation"
+
+module ADSP
+  module Test
+    module Stream
+      module Raw
+        class Compressor < Abstract
+          Target = Mock::Stream::Raw::Compressor
+          String = Mock::String
+
+          TEXTS                 = Common::TEXTS
+          LARGE_TEXTS           = Common::LARGE_TEXTS
+          PORTION_LENGTHS       = Common::PORTION_LENGTHS
+          LARGE_PORTION_LENGTHS = Common::LARGE_PORTION_LENGTHS
+
+          BUFFER_LENGTH_NAMES   = %i[destination_buffer_length].freeze
+          BUFFER_LENGTH_MAPPING = { :destination_buffer_length => :destination_buffer_length }.freeze
+
+          def test_invalid_initialize
+            get_invalid_compressor_options do |invalid_options|
+              assert_raises ValidateError do
+                Target.new invalid_options
+              end
+            end
+          end
+
+          def test_invalid_write
+            compressor = Target.new
+
+            Validation::INVALID_STRINGS.each do |invalid_string|
+              assert_raises ValidateError do
+                compressor.write invalid_string, &NOOP_PROC
+              end
+            end
+
+            assert_raises ValidateError do
+              compressor.write ""
+            end
+
+            compressor.close(&NOOP_PROC)
+
+            assert_raises UsedAfterCloseError do
+              compressor.write "", &NOOP_PROC
+            end
+          end
+
+          def test_texts
+            parallel_compressor_options do |compressor_options|
+              TEXTS.each do |text|
+                PORTION_LENGTHS.each do |portion_length|
+                  compressed_buffer = ::StringIO.new
+                  compressed_buffer.set_encoding ::Encoding::BINARY
+
+                  writer     = proc { |portion| compressed_buffer << portion }
+                  compressor = Target.new compressor_options
+
+                  begin
+                    source      = "".b
+                    text_offset = 0
+                    index       = 0
+
+                    loop do
+                      portion = text.byteslice text_offset, portion_length
+                      break if portion.nil?
+
+                      text_offset += portion_length
+                      source << portion
+
+                      bytes_written = compressor.write source, &writer
+                      source        = source.byteslice bytes_written, source.bytesize - bytes_written
+
+                      compressor.flush(&writer) if index.even?
+                      index += 1
+                    end
+
+                  ensure
+                    refute_predicate compressor, :closed?
+                    compressor.close(&writer)
+                    assert_predicate compressor, :closed?
+                  end
+
+                  compressed_text = compressed_buffer.string
+
+                  get_compatible_decompressor_options compressor_options do |decompressor_options|
+                    decompressed_text = String.decompress compressed_text, decompressor_options
+                    decompressed_text.force_encoding text.encoding
+
+                    assert_equal text, decompressed_text
+                  end
+                end
+              end
+            end
+          end
+
+          def test_large_texts
+            options_generator = OCG.new(
+              :text           => LARGE_TEXTS,
+              :portion_length => LARGE_PORTION_LENGTHS
+            )
+
+            Common.parallel_options options_generator do |options|
+              text           = options[:text]
+              portion_length = options[:portion_length]
+
+              compressed_buffer = ::StringIO.new
+              compressed_buffer.set_encoding ::Encoding::BINARY
+
+              writer     = proc { |portion| compressed_buffer << portion }
+              compressor = Target.new
+
+              begin
+                source      = "".b
+                text_offset = 0
+
+                loop do
+                  portion = text.byteslice text_offset, portion_length
+                  break if portion.nil?
+
+                  text_offset += portion_length
+                  source << portion
+
+                  bytes_written = compressor.write source, &writer
+                  source        = source.byteslice bytes_written, source.bytesize - bytes_written
+                end
+              ensure
+                compressor.close(&writer)
+              end
+
+              compressed_text = compressed_buffer.string
+
+              decompressed_text = String.decompress compressed_text
+              decompressed_text.force_encoding text.encoding
+
+              assert_equal text, decompressed_text
+            end
+          end
+
+          # -----
+
+          def get_invalid_compressor_options(&block)
+            Option.get_invalid_compressor_options BUFFER_LENGTH_NAMES, &block
+          end
+
+          def parallel_compressor_options(&block)
+            Common.parallel_options Option.get_compressor_options_generator(BUFFER_LENGTH_NAMES), &block
+          end
+
+          def get_compatible_decompressor_options(compressor_options, &block)
+            Option.get_compatible_decompressor_options compressor_options, BUFFER_LENGTH_MAPPING, &block
+          end
+        end
+
+        Minitest << Compressor
+      end
+    end
+  end
+end

data/test/stream/raw/decompressor.test.rb

@@ -0,0 +1,166 @@
+# Abstract data stream processor.
+# Copyright (c) 2021 AUTHORS, MIT License.
+
+require_relative "abstract"
+require_relative "../../common"
+require_relative "../../minitest"
+require_relative "../../mock/stream/raw/decompressor"
+require_relative "../../mock/string"
+require_relative "../../option"
+require_relative "../../validation"
+
+module ADSP
+  module Test
+    module Stream
+      module Raw
+        class Decompressor < Abstract
+          Target = Mock::Stream::Raw::Decompressor
+          String = Mock::String
+
+          TEXTS                 = Common::TEXTS
+          LARGE_TEXTS           = Common::LARGE_TEXTS
+          PORTION_LENGTHS       = Common::PORTION_LENGTHS
+          LARGE_PORTION_LENGTHS = Common::LARGE_PORTION_LENGTHS
+
+          BUFFER_LENGTH_NAMES   = %i[destination_buffer_length].freeze
+          BUFFER_LENGTH_MAPPING = { :destination_buffer_length => :destination_buffer_length }.freeze
+
+          def test_invalid_initialize
+            get_invalid_decompressor_options do |invalid_options|
+              assert_raises ValidateError do
+                Target.new invalid_options
+              end
+            end
+          end
+
+          def test_invalid_read
+            decompressor = Target.new
+
+            Validation::INVALID_STRINGS.each do |invalid_string|
+              assert_raises ValidateError do
+                decompressor.read invalid_string, &NOOP_PROC
+              end
+            end
+
+            assert_raises ValidateError do
+              decompressor.read ""
+            end
+
+            decompressor.close(&NOOP_PROC)
+
+            assert_raises UsedAfterCloseError do
+              decompressor.read "", &NOOP_PROC
+            end
+          end
+
+          def test_texts
+            parallel_compressor_options do |compressor_options|
+              TEXTS.each do |text|
+                compressed_text = String.compress text, compressor_options
+
+                PORTION_LENGTHS.each do |portion_length|
+                  get_compatible_decompressor_options compressor_options do |decompressor_options|
+                    decompressed_buffer = ::StringIO.new
+                    decompressed_buffer.set_encoding ::Encoding::BINARY
+
+                    writer       = proc { |portion| decompressed_buffer << portion }
+                    decompressor = Target.new decompressor_options
+
+                    begin
+                      source                 = "".b
+                      compressed_text_offset = 0
+                      index                  = 0
+
+                      loop do
+                        portion = compressed_text.byteslice compressed_text_offset, portion_length
+                        break if portion.nil?
+
+                        compressed_text_offset += portion_length
+                        source << portion
+
+                        bytes_read = decompressor.read source, &writer
+                        source     = source.byteslice bytes_read, source.bytesize - bytes_read
+
+                        decompressor.flush(&writer) if index.even?
+                        index += 1
+                      end
+
+                    ensure
+                      refute_predicate decompressor, :closed?
+                      decompressor.close(&writer)
+                      assert_predicate decompressor, :closed?
+                    end
+
+                    decompressed_text = decompressed_buffer.string
+                    decompressed_text.force_encoding text.encoding
+
+                    assert_equal text, decompressed_text
+                  end
+                end
+              end
+            end
+          end
+
+          def test_large_texts
+            options_generator = OCG.new(
+              :text           => LARGE_TEXTS,
+              :portion_length => LARGE_PORTION_LENGTHS
+            )
+
+            Common.parallel_options options_generator do |options|
+              text           = options[:text]
+              portion_length = options[:portion_length]
+
+              compressed_text = String.compress text
+
+              decompressed_buffer = ::StringIO.new
+              decompressed_buffer.set_encoding ::Encoding::BINARY
+
+              writer       = proc { |portion| decompressed_buffer << portion }
+              decompressor = Target.new
+
+              begin
+                source                 = "".b
+                compressed_text_offset = 0
+
+                loop do
+                  portion = compressed_text.byteslice compressed_text_offset, portion_length
+                  break if portion.nil?
+
+                  compressed_text_offset += portion_length
+                  source << portion
+
+                  bytes_read = decompressor.read source, &writer
+                  source     = source.byteslice bytes_read, source.bytesize - bytes_read
+                end
+              ensure
+                decompressor.close(&writer)
+              end
+
+              decompressed_text = decompressed_buffer.string
+              decompressed_text.force_encoding text.encoding
+
+              assert_equal text, decompressed_text
+            end
+          end
+
+          # -----
+
+          def get_invalid_decompressor_options(&block)
+            Option.get_invalid_decompressor_options BUFFER_LENGTH_NAMES, &block
+          end
+
+          def parallel_compressor_options(&block)
+            Common.parallel_options Option.get_compressor_options_generator(BUFFER_LENGTH_NAMES), &block
+          end
+
+          def get_compatible_decompressor_options(compressor_options, &block)
+            Option.get_compatible_decompressor_options compressor_options, BUFFER_LENGTH_MAPPING, &block
+          end
+        end
+
+        Minitest << Decompressor
+      end
+    end
+  end
+end