bindata 2.4.10 → 2.5.0

data/test/registry_test.rb

@@ -14,14 +14,14 @@ describe BinData::Registry do
     r.register('ASubClass', A)
     r.register('AnotherSubClass', B)
 
-    r.lookup('ASubClass').must_equal A
-    r.lookup('a_sub_class').must_equal A
-    r.lookup('AnotherSubClass').must_equal B
-    r.lookup('another_sub_class').must_equal B
+    _(r.lookup('ASubClass')).must_equal A
+    _(r.lookup('a_sub_class')).must_equal A
+    _(r.lookup('AnotherSubClass')).must_equal B
+    _(r.lookup('another_sub_class')).must_equal B
   end
 
   it "does not lookup unregistered names" do
-    lambda {
+    _ {
       r.lookup('a_non_existent_sub_class')
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -30,34 +30,34 @@ describe BinData::Registry do
     r.register('ASubClass', A)
     r.unregister('ASubClass')
 
-    lambda {
+    _ {
       r.lookup('ASubClass')
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "allows overriding of registered classes" do
-    w, $-w = $-w, false
+    w, $-w = $-w, nil  # disable warning
 
     begin
       r.register('A', A)
       r.register('A', B)
 
-      r.lookup('a').must_equal B
+      _(r.lookup('a')).must_equal B
     ensure
       $-w = w
     end
   end
 
   it "converts CamelCase to underscores" do
-    r.underscore_name('CamelCase').must_equal 'camel_case'
+    _(r.underscore_name('CamelCase')).must_equal 'camel_case'
   end
 
   it "converts adjacent caps camelCase to underscores" do
-    r.underscore_name('XYZCamelCase').must_equal 'xyz_camel_case'
+    _(r.underscore_name('XYZCamelCase')).must_equal 'xyz_camel_case'
   end
 
   it "ignores the outer nestings of classes" do
-    r.underscore_name('A::B::C').must_equal 'c'
+    _(r.underscore_name('A::B::C')).must_equal 'c'
   end
 end
 
@@ -65,14 +65,14 @@ describe BinData::Registry, "with numerics" do
   let(:r) { BinData::RegisteredClasses }
 
   it "lookup integers with endian" do
-    r.lookup("int24", {endian: :big}).to_s.must_equal "BinData::Int24be"
-    r.lookup("int24", {endian: :little}).to_s.must_equal "BinData::Int24le"
-    r.lookup("uint24", {endian: :big}).to_s.must_equal "BinData::Uint24be"
-    r.lookup("uint24", {endian: :little}).to_s.must_equal "BinData::Uint24le"
+    _(r.lookup("int24", {endian: :big}).to_s).must_equal "BinData::Int24be"
+    _(r.lookup("int24", {endian: :little}).to_s).must_equal "BinData::Int24le"
+    _(r.lookup("uint24", {endian: :big}).to_s).must_equal "BinData::Uint24be"
+    _(r.lookup("uint24", {endian: :little}).to_s).must_equal "BinData::Uint24le"
   end
 
   it "does not lookup integers without endian" do
-    lambda {
+    _ {
       r.lookup("int24")
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -81,47 +81,47 @@ describe BinData::Registry, "with numerics" do
     begin
       r.lookup("int24")
     rescue BinData::UnRegisteredTypeError => e
-      e.message.must_equal "int24, do you need to specify endian?"
+      _(e.message).must_equal "int24, do you need to specify endian?"
     end
   end
 
   it "does not lookup non byte based integers" do
-    lambda {
+    _ {
       r.lookup("int3")
     }.must_raise BinData::UnRegisteredTypeError
-    lambda {
+    _ {
       r.lookup("int3", {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
-    lambda {
+    _ {
       r.lookup("int3", {endian: :little})
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "lookup floats with endian" do
-    r.lookup("float", {endian: :big}).to_s.must_equal "BinData::FloatBe"
-    r.lookup("float", {endian: :little}).to_s.must_equal "BinData::FloatLe"
-    r.lookup("double", {endian: :big}).to_s.must_equal "BinData::DoubleBe"
-    r.lookup("double", {endian: :little}).to_s.must_equal "BinData::DoubleLe"
+    _(r.lookup("float", {endian: :big}).to_s).must_equal "BinData::FloatBe"
+    _(r.lookup("float", {endian: :little}).to_s).must_equal "BinData::FloatLe"
+    _(r.lookup("double", {endian: :big}).to_s).must_equal "BinData::DoubleBe"
+    _(r.lookup("double", {endian: :little}).to_s).must_equal "BinData::DoubleLe"
   end
 
   it "lookup bits" do
-    r.lookup("bit5").to_s.must_equal "BinData::Bit5"
-    r.lookup("sbit5").to_s.must_equal "BinData::Sbit5"
-    r.lookup("bit6le").to_s.must_equal "BinData::Bit6le"
+    _(r.lookup("bit5").to_s).must_equal "BinData::Bit5"
+    _(r.lookup("sbit5").to_s).must_equal "BinData::Sbit5"
+    _(r.lookup("bit6le").to_s).must_equal "BinData::Bit6le"
   end
 
   it "lookup bits by ignoring endian" do
-    r.lookup("bit2", {endian: :big}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {endian: :big}).to_s.must_equal "BinData::Bit3le"
-    r.lookup("bit2", {endian: :little}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {endian: :little}).to_s.must_equal "BinData::Bit3le"
+    _(r.lookup("bit2", {endian: :big}).to_s).must_equal "BinData::Bit2"
+    _(r.lookup("bit3le", {endian: :big}).to_s).must_equal "BinData::Bit3le"
+    _(r.lookup("bit2", {endian: :little}).to_s).must_equal "BinData::Bit2"
+    _(r.lookup("bit3le", {endian: :little}).to_s).must_equal "BinData::Bit3le"
   end
 
   it "lookup signed bits by ignoring endian" do
-    r.lookup("sbit2", {endian: :big}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {endian: :big}).to_s.must_equal "BinData::Sbit3le"
-    r.lookup("sbit2", {endian: :little}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {endian: :little}).to_s.must_equal "BinData::Sbit3le"
+    _(r.lookup("sbit2", {endian: :big}).to_s).must_equal "BinData::Sbit2"
+    _(r.lookup("sbit3le", {endian: :big}).to_s).must_equal "BinData::Sbit3le"
+    _(r.lookup("sbit2", {endian: :little}).to_s).must_equal "BinData::Sbit2"
+    _(r.lookup("sbit3le", {endian: :little}).to_s).must_equal "BinData::Sbit3le"
   end
 end
 
@@ -134,15 +134,15 @@ describe BinData::Registry, "with endian specific types" do
   end
   
   it "lookup little endian types" do
-    r.lookup('a', {endian: :little}).must_equal A
+    _(r.lookup('a', {endian: :little})).must_equal A
   end
 
   it "lookup big endian types" do
-    r.lookup('b', {endian: :big}).must_equal B
+    _(r.lookup('b', {endian: :big})).must_equal B
   end
 
   it "does not lookup types with non existent endian" do
-    lambda {
+    _ {
       r.lookup('a', {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -151,7 +151,7 @@ describe BinData::Registry, "with endian specific types" do
     r.register('c', C)
     r.register('c_le', D)
 
-    r.lookup('c', {endian: :little}).must_equal C
+    _(r.lookup('c', {endian: :little})).must_equal C
   end
 end
 
@@ -164,18 +164,18 @@ describe BinData::Registry, "with search_prefix" do
   end
 
   it "lookup single search_prefix" do
-    r.lookup('f', {search_prefix: :a}).must_equal A
+    _(r.lookup('f', {search_prefix: :a})).must_equal A
   end
 
   it "lookup single search_prefix with endian" do
-    r.lookup('f', {search_prefix: :a, endian: :little}).must_equal A
+    _(r.lookup('f', {search_prefix: :a, endian: :little})).must_equal A
   end
 
   it "lookup multiple search_prefix" do
-    r.lookup('f', {search_prefix: [:x, :a]}).must_equal A
+    _(r.lookup('f', {search_prefix: [:x, :a]})).must_equal A
   end
 
   it "lookup first match in search_prefix" do
-    r.lookup('f', {search_prefix: [:a, :b]}).must_equal A
+    _(r.lookup('f', {search_prefix: [:a, :b]})).must_equal A
   end
 end

data/test/rest_test.rb

@@ -6,23 +6,23 @@ describe BinData::Rest do
   let(:obj) { BinData::Rest.new }
 
   it "initial state" do
-    obj.must_equal ""
+    _(obj).must_equal ""
   end
 
   it "reads till end of stream" do
     data = "abcdefghij"
-    obj.read(data).must_equal data
+    _(obj.read(data)).must_equal data
   end
 
   it "allows setting value for completeness" do
     obj.assign("123")
-    obj.must_equal "123"
-    obj.to_binary_s.must_equal_binary "123"
+    _(obj).must_equal "123"
+    _(obj.to_binary_s).must_equal_binary "123"
   end
 
   it "accepts BinData::BasePrimitive parameters" do
     rest = BinData::Rest.new(assert: "abc")
-    lambda {
+    _ {
       rest.read("xyz")
     }.must_raise BinData::ValidityError
   end

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

@@ -6,7 +6,7 @@ describe BinData::Skip, "when instantiating" do
   describe "with no mandatory parameters supplied" do
     it "raises an error" do
       args = {}
-      lambda { BinData::Skip.new(args) }.must_raise ArgumentError
+      _ { BinData::Skip.new(args) }.must_raise ArgumentError
     end
   end
 end
@@ -16,23 +16,23 @@ describe BinData::Skip, "with :length" do
   let(:io) { StringIO.new("abcdefghij") }
 
   it "initial state" do
-    obj.must_equal ""
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj).must_equal ""
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 
   it "skips bytes" do
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "has expected binary representation after setting value" do
     obj.assign("123")
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 
   it "has expected binary representation after reading" do
     obj.read(io)
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 end
 
@@ -46,55 +46,75 @@ describe BinData::Skip, "with :to_abs_offset" do
     fields = [ skip_obj ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "reads skipping in place" do
     fields = [ [:string, :a, { read_length: 5 }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "does not read skipping backwards" do
     fields = [ [:string, :a, { read_length: 10 }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
 
-    lambda {
+    _ {
       obj.read(io)
-    }.must_raise BinData::ValidityError
+    }.must_raise ArgumentError
   end
 
   it "writes skipping forward" do
     fields = [ skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    obj.to_binary_s.must_equal "\000\000\000\000\000"
+    _(obj.to_binary_s).must_equal "\000\000\000\000\000"
   end
 
   it "reads skipping in place" do
     fields = [ [:string, :a, { value: "abcde" }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    obj.to_binary_s.must_equal "abcde"
+    _(obj.to_binary_s).must_equal "abcde"
   end
 
   it "does not write skipping backwards" do
     fields = [ [:string, :a, { value: "abcdefghij" }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    lambda {
+    _ {
       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 }] ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(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
@@ -102,36 +122,61 @@ describe BinData::Skip, "with :until_valid" do
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 0
+    _(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)
-    lambda {
+    _ {
       obj.read(io)
-    }.must_raise EOFError
+    }.must_raise IOError
   end
 
   it "raises IOError when validator reads beyond stream" do
     skip_obj = [:string, { read_length: 30 }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
-    lambda {
+    _ {
       obj.read(io)
     }.must_raise IOError
   end
 
-  class DSLSkip < BinData::Record
+  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
+
+    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
-      string read_length: 1, assert: "f"
+      uint8
+      uint8 asserted_value: 1
+      uint8 :a
+      uint8 :b
+      virtual assert: -> { a == b }
     end
-    string :a, read_length: 1
+    array :data, type: :uint8, initial_length: 4
   end
 
-  it "uses block form" do
-    obj = DSLSkip.read(io)
-    obj.a.must_equal "f"
+  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