snappy 0.0.17 → 0.3.0

data/test/hadoop/snappy_hadoop_reader_test.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopReaderTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    Snappy::Hadoop::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  def subject
+    @subject ||= Snappy::Hadoop::Reader.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Hadoop::Reader.new @buffer do |r|
+        yielded = r
+      end
+      assert_equal returned, yielded
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      assert_equal @buffer, subject.io
+    end
+
+    test "should not receive `length' in initializing" do
+      dont_allow(@buffer).length
+      Snappy::Hadoop::Reader.new @buffer
+    end
+  end
+
+  sub_test_case "#each" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each chunk" do
+      chunks = []
+      subject.each do |chunk|
+        chunks << chunk
+      end
+      assert_equal %w[foobar bazquux], chunks
+    end
+  end
+
+  sub_test_case "#read" do
+    test "should return the bytes" do
+      assert_equal "foobarbazquux", subject.read
+    end
+  end
+
+  sub_test_case "#each_line" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each line" do
+      lines = []
+      subject.each_line do |line|
+        lines << line
+      end
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each_line
+      assert_instance_of Enumerator, eacher
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "each_line split by sep_string" do
+      buffer = StringIO.new
+      Snappy::Hadoop::Writer.new buffer do |w|
+        w << %w[a b c].join(",")
+        w.dump!
+        w << %w[d e f].join(",")
+      end
+      buffer.rewind
+      reader = Snappy::Hadoop::Reader.new buffer
+      eacher = reader.each_line(",")
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[a b cd e f], lines
+    end
+  end
+end

data/test/hadoop/snappy_hadoop_writer_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopWriterTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+  end
+
+  def subject
+    @subject ||= Snappy::Hadoop::Writer.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Hadoop::Writer.new @buffer do |w|
+        yielded = w
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should write the header" do
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      assert_equal "\u0000\u0000\u0000\u0003\u0000\u0000\u0000\u0005\u0003\bfoo", @buffer.string
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      io = StringIO.new
+      assert_equal io, Snappy::Hadoop::Writer.new(io).io
+    end
+  end
+
+  sub_test_case "#block_size" do
+    test "should default to DEFAULT_BLOCK_SIZE" do
+      assert_equal Snappy::Hadoop::Writer::DEFAULT_BLOCK_SIZE, subject.block_size
+    end
+
+    test "should be settable via the constructor" do
+      assert_equal 42, Snappy::Hadoop::Writer.new(StringIO.new, 42).block_size
+    end
+  end
+end

data/test/snappy_hadoop_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopTest < Test::Unit::TestCase
+  T = [*"a".."z", *"A".."Z", *"0".."9"].freeze
+
+  def random_data(length = 1024)
+    Array.new(length) { T.sample }.join
+  end
+
+  test "well done" do
+    s = random_data
+    assert_equal s, Snappy::Hadoop.inflate(Snappy::Hadoop.deflate(s))
+  end
+
+  test "well done(pair)" do
+    s = random_data
+    [
+      %i[deflate inflate]
+    ].each do |(i, o)|
+      assert_equal s, Snappy::Hadoop.__send__(o, Snappy::Hadoop.__send__(i, s))
+    end
+  end
+end

data/test/snappy_reader_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyReaderTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    Snappy::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  def subject
+    @subject ||= Snappy::Reader.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Reader.new @buffer do |r|
+        yielded = r
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should read the header" do
+      assert_equal Snappy::Writer::MAGIC, subject.magic
+      assert_equal Snappy::Writer::DEFAULT_VERSION, subject.default_version
+      assert_equal Snappy::Writer::MINIMUM_COMPATIBLE_VERSION, subject.minimum_compatible_version
+    end
+  end
+
+  sub_test_case :initialize_without_headers do
+    def setup
+      @buffer = StringIO.new
+      @buffer << Snappy.deflate("HelloWorld" * 10)
+      @buffer.rewind
+    end
+
+    test "should inflate with a magic header" do
+      assert_equal "HelloWorld" * 10, subject.read
+    end
+
+    test "should not receive `length' in eaching" do
+      dont_allow(@buffer).length
+      subject.read
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      assert_equal @buffer, subject.io
+    end
+
+    test "should not receive `length' in initializing" do
+      dont_allow(@buffer).length
+      Snappy::Reader.new @buffer
+    end
+  end
+
+  sub_test_case "#each" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each chunk" do
+      chunks = []
+      subject.each do |chunk|
+        chunks << chunk
+      end
+      assert_equal %w[foobar bazquux], chunks
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each
+      assert_instance_of Enumerator, eacher
+      chunks = []
+      chunks << eacher.next
+      chunks << eacher.next
+      assert_raise(StopIteration) { eacher.next }
+      assert_equal %w[foobar bazquux], chunks
+    end
+  end
+
+  sub_test_case "#read" do
+    test "should return the bytes" do
+      assert_equal "foobarbazquux", subject.read
+    end
+  end
+
+  sub_test_case "#each_line" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each line" do
+      lines = []
+      subject.each_line do |line|
+        lines << line
+      end
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each_line
+      assert_instance_of Enumerator, eacher
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "each_line split by sep_string" do
+      buffer = StringIO.new
+      Snappy::Writer.new buffer do |w|
+        w << %w[a b c].join(",")
+        w.dump!
+        w << %w[d e f].join(",")
+      end
+      buffer.rewind
+      reader = Snappy::Reader.new buffer
+      eacher = reader.each_line(",")
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[a b cd e f], lines
+    end
+  end
+end

data/test/snappy_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class SnappyTest < Test::Unit::TestCase
+  T = [*"a".."z", *"A".."Z", *"0".."9"].freeze
+
+  def random_data(length = 1024)
+    Array.new(length) { T.sample }.join
+  end
+
+  test "VERSION" do
+    assert do
+      ::Snappy.const_defined?(:VERSION)
+    end
+  end
+
+  test "well done" do
+    s = random_data
+    assert_equal s, Snappy.inflate(Snappy.deflate(s))
+  end
+
+  test "well done (pair)" do
+    s = random_data
+    [
+      %i[deflate inflate],
+      %i[compress uncompress],
+      %i[dump load]
+    ].each do |(i, o)|
+      assert_equal s, Snappy.__send__(o, Snappy.__send__(i, s))
+    end
+  end
+
+  sub_test_case ".deflate" do
+    test "can pass buffer" do
+      if defined? JRUBY_VERSION
+        notify "cannot pass buffer in jruby"
+        omit
+      end
+      s = random_data
+      d = " " * 1024
+      r = Snappy.deflate(s, d)
+      assert_equal r.object_id, d.object_id
+    end
+  end
+
+  sub_test_case ".inflate" do
+    test "can pass buffer" do
+      if defined? JRUBY_VERSION
+        notify "cannot pass buffer in jruby"
+        omit
+      end
+      s = Snappy.deflate(random_data)
+      d = " " * 1024
+      r = Snappy.inflate(s, d)
+      assert_equal r.object_id, d.object_id
+    end
+  end
+
+  sub_test_case ".valid?" do
+    test "return true when passed deflated data" do
+      if defined? JRUBY_VERSION
+        notify "snappy-jars does not have valid?"
+        omit
+      end
+      d = Snappy.deflate(random_data)
+      assert_true Snappy.valid?(d)
+    end
+
+    test "return false when passed invalid data" do
+      if defined? JRUBY_VERSION
+        notify "snappy-jars does not have valid?"
+        omit
+      end
+      d = Snappy.deflate(random_data).reverse
+      assert_false Snappy.valid?(d)
+    end
+  end
+
+  sub_test_case "Ractor safe" do
+    test "able to invoke non-main ractor" do
+      unless defined? ::Ractor
+        notify "Ractor not defined"
+        omit
+      end
+      s = random_data
+      a = Array.new(2) do
+        Ractor.new(s) do |s|
+          Snappy.inflate(Snappy.deflate(s)) == s
+        end
+      end
+      assert_equal [true, true], a.map(&:take)
+    end
+  end
+end

data/test/snappy_writer_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyWriterTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+  end
+
+  def subject
+    @subject ||= Snappy::Writer.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Writer.new @buffer do |w|
+        yielded = w
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should write the header" do
+      assert_equal [Snappy::Writer::MAGIC,
+                    Snappy::Writer::DEFAULT_VERSION,
+                    Snappy::Writer::MINIMUM_COMPATIBLE_VERSION].pack("a8NN"), subject.io.string
+    end
+
+    test "should dump on the end of yield" do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      foo = Snappy.deflate "foo"
+      assert_equal [foo.size, foo].pack("Na#{foo.size}"), @buffer.string[16, @buffer.size - 16]
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      io = StringIO.new
+      assert_equal io, Snappy::Writer.new(io).io
+    end
+  end
+
+  sub_test_case "#block_size" do
+    test "should default to DEFAULT_BLOCK_SIZE" do
+      assert_equal Snappy::Writer::DEFAULT_BLOCK_SIZE, subject.block_size
+    end
+
+    test "should be settable via the constructor" do
+      assert_equal 42, Snappy::Writer.new(StringIO.new, 42).block_size
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "snappy"
+
+require "test-unit"
+require "test/unit/rr"

data/test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+docker build -t miyucy/snappy .
+docker run --rm -v "$(pwd):/app" miyucy/snappy bash -c 'bundle install && bundle exec rake'