bindata 2.4.10 → 2.5.0

data/test/system_test.rb

@@ -11,18 +11,18 @@ describe "lambdas with index" do
     arr = BinData::Array.new(type:
                                [:uint8, { value: -> { index * 10 } }],
                              initial_length: 3)
-    arr.snapshot.must_equal [0, 10, 20]
+    _(arr.snapshot).must_equal [0, 10, 20]
   end
 
   it "uses index of nearest containing array" do
     arr = BinData::Array.new(type: :nested_lambda_with_index,
                              initial_length: 3)
-    arr.snapshot.must_equal [{a: 0}, {a: 10}, {a: 20}]
+    _(arr.snapshot).must_equal [{a: 0}, {a: 10}, {a: 20}]
   end
 
   it "fails if there is no containing array" do
     obj = NestedLambdaWithIndex.new
-    lambda { obj.a.to_s }.must_raise NoMethodError
+    _ { obj.a.to_s }.must_raise NoMethodError
   end
 end
 
@@ -39,7 +39,7 @@ describe "lambdas with parent" do
     end
 
     obj = TestLambdaWithoutParent.new
-    obj.x.b.must_equal 5
+    _(obj.x.b).must_equal 5
   end
 
   it "accesses parent's parent when parent is specified" do
@@ -54,7 +54,7 @@ describe "lambdas with parent" do
     end
 
     obj = TestLambdaWithParent.new
-    obj.x.b.must_equal 3
+    _(obj.x.b).must_equal 3
   end
 end
 
@@ -82,18 +82,18 @@ describe BinData::Record, "with choice field" do
   it "treats choice object transparently " do
     obj = RecordWithChoiceField.new
 
-    obj.x.a.must_equal 3
+    _(obj.x.a).must_equal 3
   end
 
   it "treats nested choice object transparently " do
     obj = RecordWithNestedChoiceField.new
 
-    obj.x.a.must_equal 3
+    _(obj.x.a).must_equal 3
   end
 
   it "has correct offset" do
     obj = RecordWithNestedChoiceField.new
-    obj.x.b.abs_offset.must_equal 2
+    _(obj.x.b.abs_offset).must_equal 2
   end
 end
 
@@ -132,17 +132,17 @@ describe BinData::Record, "containing bitfields" do
   let(:obj) { BitfieldRecord.new }
 
   it "has correct num_bytes" do
-    obj.num_bytes.must_equal 5
+    _(obj.num_bytes).must_equal 5
   end
 
   it "reads across bitfield boundaries" do
     obj.read [0b0111_0010, 0b0110_0101, 0b0010_1010, 0b1000_0101, 0b1000_0000].pack("CCCCC")
 
-    obj.a.w.must_equal 7
-    obj.b.must_equal [0, 0, 1, 0, 0, 1, 1, 0, 0]
-    obj.c.x.must_equal 2
-    obj.d.must_equal 954
-    obj.e.must_equal 11
+    _(obj.a.w).must_equal 7
+    _(obj.b).must_equal [0, 0, 1, 0, 0, 1, 1, 0, 0]
+    _(obj.c.x).must_equal 2
+    _(obj.d).must_equal 954
+    _(obj.e).must_equal 11
   end
 
   it "writes across bitfield boundaries" do
@@ -152,37 +152,37 @@ describe BinData::Record, "containing bitfields" do
     obj.c.x = 1
     obj.d = 850
     obj.e = 35
-    obj.to_binary_s.must_equal_binary [0b0011_0010, 0b0100_0011, 0b0000_1010, 0b0001_0001, 0b1000_0000].pack("CCCCC")
+    _(obj.to_binary_s).must_equal_binary [0b0011_0010, 0b0100_0011, 0b0000_1010, 0b0001_0001, 0b1000_0000].pack("CCCCC")
   end
 end
 
 describe "Objects with debug_name" do
   it "haves default name of obj" do
     el = BinData::Uint8.new
-    el.debug_name.must_equal "obj"
+    _(el.debug_name).must_equal "obj"
   end
 
   it "includes array index" do
     arr = BinData::Array.new(type: :uint8, initial_length: 2)
-    arr[2].debug_name.must_equal "obj[2]"
+    _(arr[2].debug_name).must_equal "obj[2]"
   end
 
   it "includes field name" do
     s = BinData::Struct.new(fields: [[:uint8, :a]])
-    s.a.debug_name.must_equal "obj.a"
+    _(s.a.debug_name).must_equal "obj.a"
   end
 
   it "delegates to choice" do
     choice_params = {choices: [:uint8], selection: 0}
     s = BinData::Struct.new(fields: [[:choice, :a, choice_params]])
-    s.a.debug_name.must_equal "obj.a"
+    _(s.a.debug_name).must_equal "obj.a"
   end
 
   it "nests" do
     nested_struct_params = {fields: [[:uint8, :c]]}
     struct_params = {fields: [[:struct, :b, nested_struct_params]]}
     s = BinData::Struct.new(fields: [[:struct, :a, struct_params]])
-    s.a.b.c.debug_name.must_equal "obj.a.b.c"
+    _(s.a.b.c.debug_name).must_equal "obj.a.b.c"
   end
 end
 
@@ -194,7 +194,7 @@ describe "Tracing"  do
     BinData::trace_reading(io) { arr.read("\x01\x02\x03\x04\x05") }
 
     expected = (0..4).collect { |i| "obj[#{i}] => #{i + 1}\n" }.join("")
-    io.value.must_equal expected
+    _(io.value).must_equal expected
   end
 
   it "traces custom single values" do
@@ -209,7 +209,7 @@ describe "Tracing"  do
     io = StringIO.new
     BinData::trace_reading(io) { obj.read("\x01") }
 
-    io.value.must_equal ["obj-internal-.ex => 1\n", "obj => 1\n"].join("")
+    _(io.value).must_equal ["obj-internal-.ex => 1\n", "obj => 1\n"].join("")
   end
 
   it "traces choice selection" do
@@ -218,7 +218,7 @@ describe "Tracing"  do
     io = StringIO.new
     BinData::trace_reading(io) { obj.read("\x01") }
 
-    io.value.must_equal ["obj-selection- => 0\n", "obj => 1\n"].join("")
+    _(io.value).must_equal ["obj-selection- => 0\n", "obj => 1\n"].join("")
   end
 
   it "trims long trace values" do
@@ -227,7 +227,20 @@ describe "Tracing"  do
     io = StringIO.new
     BinData::trace_reading(io) { obj.read("0000000000111111111122222222223333333333") }
 
-    io.value.must_equal "obj => \"000000000011111111112222222222...\n"
+    _(io.value).must_equal "obj => \"000000000011111111112222222222...\n"
+  end
+
+  it "can be nested" do
+    obj = BinData::String.new(read_length: 5)
+
+    io = StringIO.new
+    BinData::trace_reading(io) {
+      BinData::trace_reading(io) {
+        obj.read("12345")
+      }
+    }
+
+    _(io.value).must_equal "obj => \"12345\"\n"
   end
 end
 
@@ -240,17 +253,17 @@ describe "Forward referencing with Primitive" do
   let(:obj) { FRPrimitive.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({len: 0, data: ""})
+    _(obj.snapshot).must_equal({len: 0, data: ""})
   end
 
   it "reads" do
     obj.read("\x04test")
-    obj.snapshot.must_equal({len: 4, data: "test"})
+    _(obj.snapshot).must_equal({len: 4, data: "test"})
   end
 
   it "sets value" do
     obj.data = "hello"
-    obj.snapshot.must_equal({len: 5, data: "hello"})
+    _(obj.snapshot).must_equal({len: 5, data: "hello"})
   end
 end
 
@@ -263,17 +276,17 @@ describe "Forward referencing with Array" do
   let(:obj) { FRArray.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({len: 0, data: []})
+    _(obj.snapshot).must_equal({len: 0, data: []})
   end
 
   it "reads" do
     obj.read("\x04\x01\x02\x03\x04")
-    obj.snapshot.must_equal({len: 4, data: [1, 2, 3, 4]})
+    _(obj.snapshot).must_equal({len: 4, data: [1, 2, 3, 4]})
   end
 
   it "sets value" do
     obj.data = [1, 2, 3]
-    obj.snapshot.must_equal({len: 3, data: [1, 2, 3]})
+    _(obj.snapshot).must_equal({len: 3, data: [1, 2, 3]})
   end
 end
 
@@ -288,7 +301,7 @@ describe "Evaluating custom parameters" do
 
   it "recursively evaluates parameter" do
     obj = CustomParameterRecord.new(zz: 5)
-    obj.c.eval_parameter(:custom).must_equal 5
+    _(obj.c.eval_parameter(:custom)).must_equal 5
   end
 end
 
@@ -299,7 +312,7 @@ describe BinData::Record, "with custom sized integers" do
 
   it "reads as expected" do
     str = "\x00\x00\x00\x00\x05"
-    CustomIntRecord.read(str).snapshot.must_equal({a: 5})
+    _(CustomIntRecord.read(str).snapshot).must_equal({a: 5})
   end
 end
 
@@ -330,11 +343,11 @@ describe BinData::Primitive, "representing a string" do
   let(:obj) { PascalStringPrimitive.new("testing") }
 
   it "compares to regexp" do
-    (obj =~ /es/).must_equal 1
+    _((obj =~ /es/)).must_equal 1
   end
 
   it "compares to regexp" do
-    (/es/ =~ obj).must_equal 1
+    _((/es/ =~ obj)).must_equal 1
   end
 end
 
@@ -347,17 +360,17 @@ describe BinData::Record, "with boolean parameters" do
 
   it "uses default parameter" do
     obj = BooleanParameterRecord.new
-    obj.a.must_equal 2
+    _(obj.a).must_equal 2
   end
 
   it "overrides parameter" do
     obj = BooleanParameterRecord.new(flag: false)
-    obj.a.must_equal 3
+    _(obj.a).must_equal 3
   end
 
   it "overrides parameter with same value" do
     obj = BooleanParameterRecord.new(flag: true)
-    obj.a.must_equal 2
+    _(obj.a).must_equal 2
   end
 end
 
@@ -372,25 +385,130 @@ describe BinData::Record, "encoding" do
 
   it "returns binary encoded data" do
     obj = EncodingTestBufferRecord.new(num: 3)
-    obj.to_binary_s.encoding.must_equal Encoding::ASCII_8BIT
+    _(obj.to_binary_s.encoding).must_equal Encoding::ASCII_8BIT
   end
 
   it "returns binary encoded data with utf-8 string" do
     obj = EncodingTestBufferRecord.new(num: 3, str: "日本語")
-    obj.to_binary_s.encoding.must_equal Encoding::ASCII_8BIT
+    _(obj.to_binary_s.encoding).must_equal Encoding::ASCII_8BIT
   end
 
   it "returns binary encoded data despite Encoding.default_internal" do
-    w, $-w = $-w, false
+    w, $-w = $-w, nil
     before_enc = Encoding.default_internal
 
     begin
       Encoding.default_internal = Encoding::UTF_8
       obj = EncodingTestBufferRecord.new(num: 3, str: "日本語")
-      obj.to_binary_s.encoding.must_equal Encoding::ASCII_8BIT
+      _(obj.to_binary_s.encoding).must_equal Encoding::ASCII_8BIT
     ensure
       Encoding.default_internal = before_enc
       $-w = w
     end
   end
 end
+
+describe BinData::Record, "buffer num_bytes" do
+  class BufferNumBytesRecord < BinData::Record
+    buffer :b, length: 10 do
+      int8 :a
+      count_bytes_remaining :nbytes
+    end
+  end
+
+  it "counts bytes remaining in the buffer" do
+    obj = BufferNumBytesRecord.read "12345678901234567890"
+    _(obj.b.nbytes).must_equal 9
+  end
+
+  it "counts bytes remaining in the buffer with short streams" do
+    obj = BufferNumBytesRecord.read "12345"
+    _(obj.b.nbytes).must_equal 4
+  end
+
+  it "assumes buffer is full with non-seekable short streams" do
+    rd, wr = IO::pipe
+    io = BinData::IO::Read.new(rd)
+    wr.write "12345"
+    wr.close
+
+    obj = BufferNumBytesRecord.read(io)
+    _(obj.b.nbytes).must_equal 9
+    rd.close
+  end
+end
+
+describe BinData::Buffer, "with seek_abs" do
+  class BufferSkipRecord < BinData::Record
+    endian :little
+    mandatory_parameter :seek_offset
+
+    uint8
+    buffer :buf, length: 5 do
+      uint8
+      uint8
+      skip to_abs_offset: :seek_offset
+      uint8 :a
+    end
+    uint8
+  end
+
+  let(:str) { "\001\002\003\004\005\006\007" }
+
+  ## TODO: enable this if we decide to allow backwards seeking
+  #backwards_seeking = false
+  #
+  #it "won't seek backwards before buffer" do
+  #  skip unless backwards_seeking
+  #  _ { BufferSkipRecord.new(seek_offset: 0).read(str) }.must_raise(IOError)
+  #end
+  #
+  #it "seeks backwards to start of buffer" do
+  #  skip unless backwards_seeking
+  #  obj = BufferSkipRecord.new(seek_offset: 1).read(str)
+  #  _(obj.buf.a).must_equal 2
+  #end
+  #
+  #it "seeks backwards inside buffer" do
+  #  skip unless backwards_seeking
+  #  obj = BufferSkipRecord.new(seek_offset: 2).read(str)
+  #  _(obj.buf.a).must_equal 3
+  #end
+
+  it "seeks forwards inside buffer" do
+    obj = BufferSkipRecord.new(seek_offset: 4).read(str)
+    _(obj.buf.a).must_equal 5
+  end
+
+  it "seeks to end of buffer" do
+    obj = BufferSkipRecord.new(seek_offset: 5).read(str)
+    _(obj.buf.a).must_equal 6
+  end
+
+  it "won't seek after buffer" do
+    _ { BufferSkipRecord.new(seek_offset: 6).read(str) }.must_raise(IOError)
+  end
+end
+
+
+describe BinData::Record, "buffered readahead" do
+  class BufferedReadaheadRecord < BinData::Record
+    buffer :a, length: 5 do
+      skip do
+        string read_length: 1, assert: "X"
+      end
+      string :b, read_length: 1
+    end
+    string :c, read_length: 1
+  end
+
+  it "reads ahead inside the buffer" do
+    obj = BufferedReadaheadRecord.read "12X4567890"
+    _(obj.a.b).must_equal "X"
+    _(obj.c).must_equal "6"
+  end
+
+  it "doesn't readahead outside the buffer" do
+    _ { BufferedReadaheadRecord.read "123456X890" }.must_raise IOError
+  end
+end

data/test/test_helper.rb

@@ -1,7 +1,9 @@
 require 'rubygems'
 
-require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+SimpleCov.start do
+  enable_coverage :branch
+end
 
 require 'minitest/autorun'
 require 'stringio'
@@ -30,32 +32,41 @@ module Kernel
   def value_read_from_written
     self.class.read(self.to_binary_s)
   end
+end
 
-  def must_equal_binary(expected)
-    must_equal expected.dup.force_encoding(Encoding::BINARY)
+module Minitest::Assertions
+  def assert_equals_binary(expected, actual)
+    assert_equal expected.dup.force_encoding(Encoding::BINARY), actual
   end
 
-  def must_raise_on_line(exp, line, msg = nil)
-    ex = self.must_raise exp
-    ex.message.must_equal msg if msg
+  def assert_raises_on_line(exp, line, msg = nil, &block)
+    ex = assert_raises(exp, &block)
+    assert_equal(msg, ex.message) if msg
 
-    idx = ex.backtrace.find_index { |bt| /:in `must_raise_on_line'$/ =~ bt }
+    idx = ex.backtrace.find_index { |bt| /:in `assert_raises_on_line'$/ =~ bt }
 
     line_num_regex = /.*:(\d+)(:.*|$)/
     err_line = line_num_regex.match(ex.backtrace[0])[1].to_i
-    ref_line = line_num_regex.match(ex.backtrace[idx + 1])[1].to_i
+    ref_line = line_num_regex.match(ex.backtrace[idx + 2])[1].to_i
 
-    (err_line - ref_line).must_equal line
+    assert_equal((err_line - ref_line), line)
   end
 
-  def must_warn(msg, &block)
+  def assert_warns(msg, &block)
     result = ""
     callable = proc { |str|
       result = str
     }
-    self.stub(:warn, callable) do
+    Kernel.stub(:warn, callable) do
       block.call
     end
-    result.must_equal msg
+
+    assert_equal msg, result
   end
 end
+
+module Minitest::Expectations
+  infect_an_assertion :assert_equals_binary, :must_equal_binary
+  infect_an_assertion :assert_raises_on_line, :must_raise_on_line, :block
+  infect_an_assertion :assert_warns, :must_warn, :block
+end

data/test/uint8_array_test.rb

@@ -5,17 +5,17 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 describe BinData::Uint8Array, "when initialising" do
   it "with mutually exclusive parameters :initial_length and :read_until" do
     params = {initial_length: 5, read_until: :eof}
-    lambda { BinData::Uint8Array.new(params) }.must_raise ArgumentError
+    _ { BinData::Uint8Array.new(params) }.must_raise ArgumentError
   end
 
   it "with :read_until" do
     params = {read_until: :not_eof}
-    lambda { BinData::Uint8Array.new(params) }.must_raise ArgumentError
+    _ { BinData::Uint8Array.new(params) }.must_raise ArgumentError
   end
 
   it "with no parameters" do
     arr = BinData::Uint8Array.new
-    arr.num_bytes.must_equal 0
+    _(arr.num_bytes).must_equal 0
   end
 end
 
@@ -23,7 +23,7 @@ describe BinData::Uint8Array, "with :read_until" do
   it "reads until :eof" do
     arr = BinData::Uint8Array.new(read_until: :eof)
     arr.read("\xff\xfe\xfd\xfc")
-    arr.must_equal([255, 254, 253, 252])
+    _(arr).must_equal([255, 254, 253, 252])
   end
 end
 
@@ -31,7 +31,7 @@ describe BinData::Uint8Array, "with :initial_length" do
   it "reads" do
     arr = BinData::Uint8Array.new(initial_length: 3)
     arr.read("\xff\xfe\xfd\xfc")
-    arr.must_equal([255, 254, 253])
+    _(arr).must_equal([255, 254, 253])
   end
 end
 
@@ -39,6 +39,6 @@ describe BinData::Uint8Array, "when assigning" do
   it "copies data" do
     arr = BinData::Uint8Array.new
     arr.assign([1, 2, 3])
-    arr.must_equal([1, 2, 3])
+    _(arr).must_equal([1, 2, 3])
   end
 end

data/test/virtual_test.rb

@@ -7,17 +7,17 @@ describe BinData::Virtual do
 
   it "must not read from any stream" do
     BinData::Virtual.read(stream)
-    stream.pos.must_equal 0
+    _(stream.pos).must_equal 0
   end
 
   it "must not write to a stream" do
     obj = BinData::Virtual.new
-    obj.to_binary_s.must_equal_binary ""
+    _(obj.to_binary_s).must_equal_binary ""
   end
 
   it "occupies no space" do
     obj = BinData::Virtual.new
-    obj.num_bytes.must_equal 0
+    _(obj.num_bytes).must_equal 0
   end
 
   it "asserts on #read" do
@@ -25,7 +25,7 @@ describe BinData::Virtual do
     obj = BinData::Virtual.new(assert: -> { data << 1; true })
 
     obj.read ""
-    data.must_equal [1]
+    _(data).must_equal [1]
   end
 
   it "asserts on #assign" do
@@ -33,16 +33,16 @@ describe BinData::Virtual do
     obj = BinData::Virtual.new(assert: -> { data << 1; true })
 
     obj.assign("foo")
-    data.must_equal [1]
+    _(data).must_equal [1]
   end
 
   it "assigns a value" do
     obj = BinData::Virtual.new(3)
-    obj.must_equal 3
+    _(obj).must_equal 3
   end
 
   it "accepts the :value parameter" do
     obj = BinData::Virtual.new(value: 3)
-    obj.must_equal 3
+    _(obj).must_equal 3
   end
 end

data/test/warnings_test.rb

@@ -10,11 +10,23 @@ describe BinData::Base, "when defining" do
       end
     end
 
-    lambda {
+    _ {
       BaseWithInitialize.new
     }.must_raise RuntimeError
   end
 
+  it "fails if #initialize is overridden on BasePrimitive" do
+    class BasePrimitiveWithInitialize < BinData::String
+      def initialize(params = {}, parent = nil)
+        super
+      end
+    end
+
+    _ {
+      BasePrimitiveWithInitialize.new
+    }.must_raise RuntimeError
+  end
+
   it "handles if #initialize is naively renamed to #initialize_instance" do
     class BaseWithInitializeInstance < BinData::Base
       def initialize_instance(params = {}, parent = nil)
@@ -22,7 +34,7 @@ describe BinData::Base, "when defining" do
       end
     end
 
-    lambda {
+    _ {
       BaseWithInitializeInstance.new
     }.must_raise RuntimeError
   end