bindata 2.4.14 → 2.5.0

data/test/array_test.rb

@@ -18,17 +18,15 @@ describe BinData::Array, "when instantiating" do
   end
 
   it "warns about :length" do
-    Kernel.must_warn ":length is not used with BinData::Array.  You probably want to change this to :initial_length" do
-    obj = BinData::Array.new(type: :uint8, length: 3)
-      obj.read "123"
-    end
+    _ {
+      BinData::Array.new(type: :uint8, length: 3)
+    }.must_warn ":length is not used with BinData::Array.  You probably want to change this to :initial_length"
   end
 
   it "warns about :read_length" do
-    Kernel.must_warn ":read_length is not used with BinData::Array.  You probably want to change this to :initial_length" do
-    obj = BinData::Array.new(type: :uint8, read_length: 3)
-      obj.read "123"
-    end
+    _ {
+      BinData::Array.new(type: :uint8, read_length: 3)
+    }.must_warn ":read_length is not used with BinData::Array.  You probably want to change this to :initial_length"
   end
 
   it "fails if a given type is unknown" do
@@ -71,6 +69,10 @@ describe BinData::Array, "with no elements" do
   it "returns [] for the last n elements" do
     _(obj.last(3)).must_equal []
   end
+
+  it "won't assign nil" do
+    _ { obj.assign(nil) }.must_raise ArgumentError
+  end
 end
 
 describe BinData::Array, "with several elements" do

data/test/buffer_test.rb

@@ -144,6 +144,15 @@ describe BinData::Buffer, "nested buffers" do
     _(obj.b).must_equal "klmno"
   end
 
+  it "pads undersize writes" do
+    obj = NestedBufferRecord.new
+    obj.a.aa = "abc"
+    obj.a.bb = "ABC"
+    obj.b = "123"
+
+    _(obj.to_binary_s).must_equal_binary "abc\000\000ABC\000\000123"
+  end
+
   it "restricts oversize writes" do
     obj = NestedBufferRecord.new
     obj.a.aa = "abcdefghij"

data/test/choice_test.rb

@@ -243,7 +243,7 @@ describe BinData::Choice, "subclassed with default parameters" do
     _(obj.num_bytes).must_equal 2
   end
 
-  it "overides default parameter" do
+  it "overrides default parameter" do
     obj = DerivedChoice.new(selection: 'b')
     _(obj.num_bytes).must_equal 4
   end

data/test/delayed_io_test.rb

@@ -266,3 +266,19 @@ describe BinData::DelayedIO, "with auto_call" do
     _(obj.num_bytes).must_equal 2
   end
 end
+
+describe BinData::DelayedIO, "with multiple auto_call" do
+  class MultipleAutoCallDelayedIORecord < BinData::Record
+    auto_call_delayed_io
+    auto_call_delayed_io
+    uint8 :a
+    delayed_io :b, read_abs_offset: 1 do
+      uint8
+    end
+  end
+
+  it "class reads" do
+    obj = MultipleAutoCallDelayedIORecord.read "\x01\x02"
+    _(obj.snapshot).must_equal({a: 1, b: 2})
+  end
+end

data/test/io_test.rb

@@ -15,16 +15,24 @@ describe BinData::IO::Read, "reading from non seekable stream" do
     @rd.close
   end
 
-  it "has correct offset" do
-    @io.readbytes(10)
-    _(@io.offset).must_equal 10
+  it "seeks correctly" do
+    @io.skipbytes(1999)
+    _(@io.readbytes(5)).must_equal "abbbb"
   end
 
-  it "seeks correctly" do
-    @io.seekbytes(1999)
+  it "seeks to abs_offset" do
+    @io.skipbytes(1000)
+    @io.seek_to_abs_offset(1999)
     _(@io.readbytes(5)).must_equal "abbbb"
   end
 
+  it "wont seek backwards" do
+    @io.skipbytes(5)
+    _ {
+      @io.skipbytes(-1)
+    }.must_raise IOError
+  end
+
   it "#num_bytes_remaining raises IOError" do
     _ {
       @io.num_bytes_remaining
@@ -32,6 +40,35 @@ describe BinData::IO::Read, "reading from non seekable stream" do
   end
 end
 
+describe BinData::IO::Write, "writing to non seekable stream" do
+  before do
+    @rd, @wr = IO::pipe
+    @io = BinData::IO::Write.new(@wr)
+  end
+
+  after do
+    @rd.close
+    @wr.close
+  end
+
+  def written_data
+    @io.flush
+    @wr.close
+    @rd.read
+  end
+
+  it "writes correctly" do
+    @io.writebytes("hello")
+    _(written_data).must_equal "hello"
+  end
+
+  it "must not attempt to seek" do
+    _ {
+      @io.seek_to_abs_offset(5)
+    }.must_raise IOError
+  end
+end
+
 describe BinData::IO::Read, "when reading" do
   let(:stream) { StringIO.new "abcdefghij" }
   let(:io) { BinData::IO::Read.new(stream) }
@@ -42,19 +79,19 @@ describe BinData::IO::Read, "when reading" do
     }.must_raise ArgumentError
   end
 
-  it "returns correct offset" do
-    stream.seek(3, IO::SEEK_CUR)
-
-    _(io.offset).must_equal 0
-    _(io.readbytes(4)).must_equal "defg"
-    _(io.offset).must_equal 4
-  end
-
   it "seeks correctly" do
-    io.seekbytes(2)
+    io.skipbytes(2)
     _(io.readbytes(4)).must_equal "cdef"
   end
 
+  it "wont seek backwards" do
+    io.skipbytes(5)
+    _ {
+      io.skipbytes(-1)
+    }.must_raise IOError
+  end
+
+
   it "reads all bytes" do
     _(io.read_all_bytes).must_equal "abcdefghij"
   end
@@ -67,7 +104,7 @@ describe BinData::IO::Read, "when reading" do
   end
 
   it "raises error when reading at eof" do
-    io.seekbytes(10)
+    io.skipbytes(10)
     _ {
       io.readbytes(3)
     }.must_raise EOFError
@@ -80,149 +117,6 @@ describe BinData::IO::Read, "when reading" do
   end
 end
 
-describe BinData::IO::Read, "#with_buffer" do
-  let(:stream) { StringIO.new "abcdefghijklmnopqrst" }
-  let(:io) { BinData::IO::Read.new(stream) }
-
-  it "consumes entire buffer on short reads" do
-    io.with_buffer(10) do
-      _(io.readbytes(4)).must_equal "abcd"
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "consumes entire buffer on read_all_bytes" do
-    io.with_buffer(10) do
-      _(io.read_all_bytes).must_equal "abcdefghij"
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "restricts large reads" do
-    io.with_buffer(10) do
-      _ {
-        io.readbytes(15)
-      }.must_raise IOError
-    end
-  end
-
-  it "is nestable" do
-    io.with_buffer(10) do
-      _(io.readbytes(2)).must_equal "ab"
-      io.with_buffer(5) do
-        _(io.read_all_bytes).must_equal "cdefg"
-      end
-      _(io.offset).must_equal(2 + 5)
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "restricts large nested buffers" do
-    io.with_buffer(10) do
-      _(io.readbytes(2)).must_equal "ab"
-      io.with_buffer(20) do
-        _(io.read_all_bytes).must_equal "cdefghij"
-        _(io.offset).must_equal(10)
-      end
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "restricts large seeks" do
-    io.with_buffer(10) do
-      io.seekbytes(15)
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "restricts large -ve seeks" do
-    io.readbytes(2)
-    io.with_buffer(10) do
-      io.seekbytes(-1)
-      _(io.offset).must_equal(2)
-    end
-  end
-
-  it "greater than stream size consumes all bytes" do
-    io.with_buffer(30) do
-      _(io.readbytes(4)).must_equal "abcd"
-    end
-    _(io.offset).must_equal(20)
-  end
-
-  it "restricts #num_bytes_remaining" do
-    io.with_buffer(10) do
-      io.readbytes(2)
-      _(io.num_bytes_remaining).must_equal 8
-    end
-  end
-
-  it "greater than stream size doesn't restrict #num_bytes_remaining" do
-    io.with_buffer(30) do
-      io.readbytes(2)
-      _(io.num_bytes_remaining).must_equal 18
-    end
-  end
-end
-
-module IOReadWithReadahead
-  def test_rolls_back_short_reads
-    _(io.readbytes(2)).must_equal "ab"
-    io.with_readahead do
-      _(io.readbytes(4)).must_equal "cdef"
-    end
-    _(io.offset).must_equal 2
-  end
-
-  def test_rolls_back_read_all_bytes
-    _(io.readbytes(3)).must_equal "abc"
-    io.with_readahead do
-      _(io.read_all_bytes).must_equal "defghijklmnopqrst"
-    end
-    _(io.offset).must_equal 3
-  end
-
-  def test_inside_buffer_rolls_back_reads
-    io.with_buffer(10) do
-      io.with_readahead do
-        _(io.readbytes(4)).must_equal "abcd"
-      end
-      _(io.offset).must_equal 0
-    end
-    _(io.offset).must_equal 10
-  end
-
-  def test_outside_buffer_rolls_back_reads
-    io.with_readahead do
-      io.with_buffer(10) do
-        _(io.readbytes(4)).must_equal "abcd"
-      end
-      _(io.offset).must_equal 10
-    end
-    _(io.offset).must_equal 0
-  end
-end
-
-describe BinData::IO::Read, "#with_readahead" do
-  let(:stream) { StringIO.new "abcdefghijklmnopqrst" }
-  let(:io) { BinData::IO::Read.new(stream) }
-
-  include IOReadWithReadahead
-end
-
-describe BinData::IO::Read, "unseekable stream #with_readahead" do
-  let(:stream) {
-    io = StringIO.new "abcdefghijklmnopqrst"
-    def io.pos
-      raise Errno::EPIPE
-    end
-    io
-  }
-  let(:io) { BinData::IO::Read.new(stream) }
-
-  include IOReadWithReadahead
-end
-
 describe BinData::IO::Write, "writing to non seekable stream" do
   before do
     @rd, @wr = IO::pipe
@@ -238,30 +132,6 @@ describe BinData::IO::Write, "writing to non seekable stream" do
     @io.writebytes("1234567890")
     _(@rd.read(10)).must_equal "1234567890"
   end
-
-  it "has correct offset" do
-    @io.writebytes("1234567890")
-    _(@io.offset).must_equal 10
-  end
-
-  it "does not seek backwards" do
-    @io.writebytes("1234567890")
-    _ {
-      @io.seekbytes(-5)
-    }.must_raise IOError
-  end
-
-  it "does not seek forwards" do
-    _ {
-      @io.seekbytes(5)
-    }.must_raise IOError
-  end
-
-  it "#num_bytes_remaining raises IOError" do
-    _ {
-      @io.num_bytes_remaining
-    }.must_raise IOError
-  end
 end
 
 describe BinData::IO::Write, "when writing" do
@@ -280,21 +150,6 @@ describe BinData::IO::Write, "when writing" do
     _(stream.value).must_equal "abcd"
   end
 
-  it "has #offset" do
-    _(io.offset).must_equal 0
-
-    io.writebytes("abcd")
-    _(io.offset).must_equal 4
-
-    io.writebytes("ABCD")
-    _(io.offset).must_equal 8
-  end
-
-  it "rounds up #offset when writing bits" do
-    io.writebits(123, 9, :little)
-    _(io.offset).must_equal 2
-  end
-
   it "flushes" do
     io.writebytes("abcd")
     io.flush
@@ -303,53 +158,6 @@ describe BinData::IO::Write, "when writing" do
   end
 end
 
-describe BinData::IO::Write, "#with_buffer" do
-  let(:stream) { StringIO.new }
-  let(:io) { BinData::IO::Write.new(stream) }
-
-  it "pads entire buffer on short reads" do
-    io.with_buffer(10) do
-      io.writebytes "abcde"
-    end
-
-    _(stream.value).must_equal "abcde\0\0\0\0\0"
-  end
-
-  it "discards excess on large writes" do
-    io.with_buffer(5) do
-      io.writebytes "abcdefghij"
-    end
-
-    _(stream.value).must_equal "abcde"
-  end
-
-  it "is nestable" do
-    io.with_buffer(10) do
-      io.with_buffer(5) do
-        io.writebytes "abc"
-      end
-      io.writebytes "de"
-    end
-
-    _(stream.value).must_equal "abc\0\0de\0\0\0"
-  end
-
-  it "restricts large seeks" do
-    io.with_buffer(10) do
-      io.seekbytes(15)
-    end
-    _(io.offset).must_equal(10)
-  end
-
-  it "restricts large -ve seeks" do
-    io.writebytes("12")
-    io.with_buffer(10) do
-      io.seekbytes(-1)
-      _(io.offset).must_equal(2)
-    end
-  end
-end
-
 describe BinData::IO::Read, "reading bits in big endian" do
   let(:b1) { 0b1111_1010 }
   let(:b2) { 0b1100_1110 }
@@ -554,7 +362,7 @@ describe BinData::IO::Write, "writing bits in little endian" do
 end
 
 describe BinData::IO::Read, "with changing endian" do
-  it "does not mix different endianess when reading" do
+  it "does not mix different endianness when reading" do
     b1 = 0b0110_1010
     b2 = 0b1110_0010
     str = [b1, b2].pack("CC")
@@ -566,7 +374,7 @@ describe BinData::IO::Read, "with changing endian" do
 end
 
 describe BinData::IO::Write, "with changing endian" do
-  it "does not mix different endianess when writing" do
+  it "does not mix different endianness when writing" do
     io = BitWriterHelper.new
     io.writebits(0b110, 3, :big)
     io.writebits(0b010, 3, :little)

data/test/registry_test.rb

@@ -36,7 +36,7 @@ describe BinData::Registry do
   end
 
   it "allows overriding of registered classes" do
-    w, $-w = $-w, false
+    w, $-w = $-w, nil  # disable warning
 
     begin
       r.register('A', A)

data/test/section_test.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+
+describe BinData::Section do
+  it "transforms data byte at a time" do
+    require 'bindata/transform/xor'
+
+    obj = BinData::Section.new(transform: -> { BinData::Transform::Xor.new(0xff) },
+                               type: [:string, read_length: 5])
+
+    _(obj.read("\x97\x9A\x93\x93\x90")).must_equal "hello"
+  end
+
+  begin
+    require 'brotli'
+    it "transform brotli" do
+      require 'bindata/transform/brotli'
+
+      class BrotliRecord < BinData::Record
+        int32le :len, value: -> { s.num_bytes }
+        section :s, transform: -> { BinData::Transform::Brotli.new(len) } do
+          int32le :str_len, value: -> { str.length }
+          string :str, read_length: :str_len
+
+        end
+      end
+
+      obj = BrotliRecord.new
+      data = "highly compressible" * 100
+      obj.s.str = data
+      _(obj.len).must_be :<, (data.length / 10)
+
+      str =  obj.to_binary_s
+      obj = BrotliRecord.read(str)
+      _(obj.s.str).must_equal data
+    end
+  rescue LoadError; end
+
+  begin
+    require 'extlz4'
+    it "transform lz4" do
+      require 'bindata/transform/lz4'
+
+      class LZ4Record < BinData::Record
+        int32le :len, value: -> { s.num_bytes }
+        section :s, transform: -> { BinData::Transform::LZ4.new(len) } do
+          int32le :str_len, value: -> { str.length }
+          string :str, read_length: :str_len
+
+        end
+      end
+
+      obj = LZ4Record.new
+      data = "highly compressible" * 100
+      obj.s.str = data
+      _(obj.len).must_be :<, (data.length / 10)
+
+      str =  obj.to_binary_s
+      obj = LZ4Record.read(str)
+      _(obj.s.str).must_equal data
+    end
+  rescue LoadError; end
+
+  it "transform zlib" do
+    require 'bindata/transform/zlib'
+
+    class ZlibRecord < BinData::Record
+      int32le :len, value: -> { s.num_bytes }
+      section :s, transform: -> { BinData::Transform::Zlib.new(len) } do
+        int32le :str_len, value: -> { str.length }
+        string :str, read_length: :str_len
+
+      end
+    end
+
+    obj = ZlibRecord.new
+    data = "highly compressible" * 100
+    obj.s.str = data
+    _(obj.len).must_be :<, (data.length / 10)
+
+    str =  obj.to_binary_s
+    obj = ZlibRecord.read(str)
+    _(obj.s.str).must_equal data
+  end
+
+  begin
+    require 'zstd-ruby'
+    it "transform zstd" do
+      require 'bindata/transform/zstd'
+
+      class ZstdRecord < BinData::Record
+        int32le :len, value: -> { s.num_bytes }
+        section :s, transform: -> { BinData::Transform::Zstd.new(len) } do
+          int32le :str_len, value: -> { str.length }
+          string :str, read_length: :str_len
+
+        end
+      end
+
+      obj = ZstdRecord.new
+      data = "highly compressible" * 100
+      obj.s.str = data
+      _(obj.len).must_be :<, (data.length / 10)
+
+      str =  obj.to_binary_s
+      obj = ZstdRecord.read(str)
+      _(obj.s.str).must_equal data
+    end
+  rescue LoadError; end
+end

data/test/skip_test.rb

@@ -62,7 +62,7 @@ describe BinData::Skip, "with :to_abs_offset" do
 
     _ {
       obj.read(io)
-    }.must_raise BinData::ValidityError
+    }.must_raise ArgumentError
   end
 
   it "writes skipping forward" do
@@ -82,13 +82,20 @@ describe BinData::Skip, "with :to_abs_offset" do
     obj = BinData::Struct.new(fields: fields)
     _ {
       obj.to_binary_s
-    }.must_raise BinData::ValidityError
+    }.must_raise ArgumentError
   end
 end
 
 describe BinData::Skip, "with :until_valid" do
   let(:io) { StringIO.new("abcdefghij") }
 
+  it "doesn't skip when writing" do
+    skip_obj = [:string, { read_length: 1, assert: "f" }]
+    args = { until_valid: skip_obj }
+    obj = BinData::Skip.new(args)
+    _(obj.to_binary_s).must_equal ""
+  end
+
   it "skips to valid match" do
     skip_obj = [:string, { read_length: 1, assert: "f" }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
@@ -97,6 +104,19 @@ describe BinData::Skip, "with :until_valid" do
     _(io.pos).must_equal 5
   end
 
+  it "won't skip on unseekable stream" do
+    rd, wr = IO::pipe
+    unseekable_io = BinData::IO::Read.new(rd)
+    wr.write io
+    wr.close
+
+    skip_obj = [:string, { read_length: 1, assert: "f" }]
+    fields = [ [:skip, :s, { until_valid: skip_obj }] ]
+    obj = BinData::Struct.new(fields: fields)
+    _ {obj.read(unseekable_io)}.must_raise IOError
+    rd.close
+  end
+
   it "doesn't skip when validator doesn't assert" do
     skip_obj = [:string, { read_length: 1 }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
@@ -105,13 +125,13 @@ describe BinData::Skip, "with :until_valid" do
     _(io.pos).must_equal 0
   end
 
-  it "raises EOFError when no match" do
+  it "raises IOError when no match" do
     skip_obj = [:string, { read_length: 1, assert: "X" }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
     _ {
       obj.read(io)
-    }.must_raise EOFError
+    }.must_raise IOError
   end
 
   it "raises IOError when validator reads beyond stream" do
@@ -123,15 +143,40 @@ describe BinData::Skip, "with :until_valid" do
     }.must_raise IOError
   end
 
-  class DSLSkip < BinData::Record
-    skip :s do
-      string read_length: 1, assert: "f"
+  it "uses block form" do
+    class DSLSkip < BinData::Record
+      skip :s do
+        string read_length: 1, assert: "f"
+      end
+      string :a, read_length: 1
     end
-    string :a, read_length: 1
-  end
 
-  it "uses block form" do
     obj = DSLSkip.read(io)
     _(obj.a).must_equal "f"
   end
 end
+
+describe BinData::Skip, "with :until_valid" do
+  class SkipSearch < BinData::Record
+    skip :s do
+      uint8
+      uint8 asserted_value: 1
+      uint8 :a
+      uint8 :b
+      virtual assert: -> { a == b }
+    end
+    array :data, type: :uint8, initial_length: 4
+  end
+
+  let(:io) { BinData::IO.create_string_io("\x0f" * 10 + "\x00\x01\x02\x03\x00" + "\x02\x01\x03\x03" + "\x06") }
+
+  it "finds valid match" do
+    obj = SkipSearch.read(io)
+    _(obj.data).must_equal [2, 1, 3, 3]
+  end
+
+  it "match is at expected offset" do
+    obj = SkipSearch.read(io)
+    _(obj.data.rel_offset).must_equal 15
+  end
+end