bindata 2.4.10 → 2.5.0

data/test/buffer_test.rb

@@ -6,26 +6,26 @@ describe BinData::Buffer, "when instantiating" do
   describe "with no mandatory parameters supplied" do
     it "raises an error" do
       args = {}
-      lambda { BinData::Buffer.new(args) }.must_raise ArgumentError
+      _ { BinData::Buffer.new(args) }.must_raise ArgumentError
     end
   end
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
       args = {length: 3}
-      lambda { BinData::Buffer.new(args) }.must_raise ArgumentError
+      _ { BinData::Buffer.new(args) }.must_raise ArgumentError
     end
   end
 
   it "fails if a given type is unknown" do
     args = {type: :does_not_exist, length: 3}
-    lambda { BinData::Buffer.new(args) }.must_raise BinData::UnRegisteredTypeError
+    _ { BinData::Buffer.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "accepts BinData::Base as :type" do
     obj = BinData::Int8.new(initial_value: 5)
     array = BinData::Buffer.new(type: obj, length: 3)
-    array.must_equal 5
+    _(array).must_equal 5
   end
 end
 
@@ -39,29 +39,29 @@ describe BinData::Buffer, "subclassed with a single type" do
 
   it "behaves as type" do
     obj = IntBuffer.new(3)
-    obj.must_equal 3
+    _(obj).must_equal 3
   end
 
   it "reads data" do
     obj = IntBuffer.read "\001\002\003\004\005"
-    obj.must_equal 0x0102
+    _(obj).must_equal 0x0102
   end
 
   it "writes data" do
     obj = IntBuffer.new(3)
-    obj.to_binary_s.must_equal_binary "\000\003\000\000\000"
+    _(obj.to_binary_s).must_equal_binary "\000\003\000\000\000"
   end
 
   it "has total num_bytes" do
     obj = IntBuffer.new
     assert obj.clear?
-    obj.num_bytes.must_equal 5
+    _(obj.num_bytes).must_equal 5
   end
 
   it "has raw_num_bytes" do
     obj = IntBuffer.new
     assert obj.clear?
-    obj.raw_num_bytes.must_equal 2
+    _(obj.raw_num_bytes).must_equal 2
   end
 end
 
@@ -76,29 +76,29 @@ describe BinData::Buffer, "subclassed with multiple types" do
 
   it "behaves as type" do
     obj = TupleBuffer.new(a: 1, b: 2)
-    obj.a.must_equal 1
-    obj.b.must_equal 2
+    _(obj.a).must_equal 1
+    _(obj.b).must_equal 2
   end
 
   it "has total num_bytes" do
     obj = TupleBuffer.new
-    obj.num_bytes.must_equal 5
+    _(obj.num_bytes).must_equal 5
   end
 
   it "has raw_num_bytes" do
     obj = TupleBuffer.new
-    obj.raw_num_bytes.must_equal 4
+    _(obj.raw_num_bytes).must_equal 4
   end
 
   it "reads data" do
     obj = TupleBuffer.read "\001\002\003\004\005"
-    obj.a.must_equal 0x0102
-    obj.b.must_equal 0x0304
+    _(obj.a).must_equal 0x0102
+    _(obj.b).must_equal 0x0304
   end
 
   it "writes data" do
     obj = TupleBuffer.new(a: 1, b: 2)
-    obj.to_binary_s.must_equal_binary "\000\001\000\002\000"
+    _(obj.to_binary_s).must_equal_binary "\000\001\000\002\000"
   end
 end
 
@@ -115,12 +115,12 @@ describe BinData::Buffer, "inside a Record" do
 
   it "reads" do
     obj = BufferRecord.read "\007\000\004\000\005\000\006\000\000ZZ"
-    obj.list.must_equal [4, 5, 6]
+    _(obj.list).must_equal [4, 5, 6]
   end
 
   it "writes" do
     obj = BufferRecord.new(list: [1, 2, 3, 4, 5])
-    obj.to_binary_s.must_equal_binary "\013\000\001\000\002\000\003\000\004\000\005\000\000ZZ"
+    _(obj.to_binary_s).must_equal_binary "\013\000\001\000\002\000\003\000\004\000\005\000\000ZZ"
   end
 end
 
@@ -139,9 +139,18 @@ describe BinData::Buffer, "nested buffers" do
 
   it "restricts large nested buffer" do
     obj = NestedBufferRecord.read "abcdefghijklmnopqrst"
-    obj.a.aa.must_equal "abcde"
-    obj.a.bb.must_equal "fghij"
-    obj.b.must_equal "klmno"
+    _(obj.a.aa).must_equal "abcde"
+    _(obj.a.bb).must_equal "fghij"
+    _(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
@@ -150,6 +159,6 @@ describe BinData::Buffer, "nested buffers" do
     obj.a.bb = "ABCDEFGHIJ"
     obj.b = "12345"
 
-    obj.to_binary_s.must_equal_binary "abcdeABCDE12345"
+    _(obj.to_binary_s).must_equal_binary "abcdeABCDE12345"
   end
 end

data/test/choice_test.rb

@@ -26,84 +26,84 @@ end
 describe BinData::Choice, "when instantiating" do
   it "ensures mandatory parameters are supplied" do
     args = {}
-    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+    _ { BinData::Choice.new(args) }.must_raise ArgumentError
 
     args = {selection: 1}
-    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+    _ { BinData::Choice.new(args) }.must_raise ArgumentError
 
     args = {choices: []}
-    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+    _ { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 
   it "fails when a given type is unknown" do
     args = {choices: [:does_not_exist], selection: 0}
-    lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
+    _ { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails when a given type is unknown" do
     args = {choices: {0 => :does_not_exist}, selection: 0}
-    lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
+    _ { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails when :choices Hash has a symbol as key" do
     args = {choices: {a: :uint8}, selection: 0}
-    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+    _ { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 
   it "fails when :choices Hash has a nil key" do
     args = {choices: {nil => :uint8}, selection: 0}
-    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+    _ { BinData::Choice.new(args) }.must_raise ArgumentError
   end
 end
 
 module ChoiceInitializedWithArrayOrHash
   def test_can_select_the_choice
     obj.choice = 3
-    obj.must_equal 30
+    _(obj).must_equal 30
   end
 
   def test_shows_the_current_selection
     obj.choice = 3
-    obj.selection.must_equal 3
+    _(obj.selection).must_equal 3
   end
 
   def test_forwards_snapshot
     obj.choice = 3
-    obj.snapshot.must_equal 30
+    _(obj.snapshot).must_equal 30
   end
 
   def test_can_change_the_choice
     obj.choice = 3
 
     obj.choice = 7
-    obj.must_equal 70
+    _(obj).must_equal 70
   end
 
   def test_fails_if_no_choice_has_been_set
-    lambda { obj.to_s }.must_raise IndexError
+    _ { obj.to_s }.must_raise IndexError
   end
 
   def test_wont_select_an_invalid_choice
     obj.choice = 99
-    lambda { obj.to_s }.must_raise IndexError
+    _ { obj.to_s }.must_raise IndexError
   end
 
   def test_wont_select_a_nil_choice
     obj.choice = 1
-    lambda { obj.to_s }.must_raise IndexError
+    _ { obj.to_s }.must_raise IndexError
   end
 
   def test_handles_missing_methods_correctly
     obj.choice = 3
 
-    obj.must_respond_to :value
-    obj.wont_respond_to :does_not_exist
-    lambda { obj.does_not_exist }.must_raise NoMethodError
+    _(obj).must_respond_to :value
+    _(obj).wont_respond_to :does_not_exist
+    _ { obj.does_not_exist }.must_raise NoMethodError
   end
 
   def test_delegates_methods_to_the_selected_single_choice
     obj.choice = 5
-    obj.num_bytes.must_equal 1
+    _(obj.num_bytes).must_equal 1
   end
 end
 
@@ -138,7 +138,7 @@ describe BinData::Choice, "with single values" do
   it "assigns raw values" do
     obj.choice = 3
     obj.assign(254)
-    obj.must_equal 254
+    _(obj).must_equal 254
   end
 
   it "assigns BinData values" do
@@ -146,7 +146,7 @@ describe BinData::Choice, "with single values" do
 
     obj.choice = 3
     obj.assign(data)
-    obj.must_equal 11
+    _(obj).must_equal 11
   end
 
   it "clears" do
@@ -154,7 +154,7 @@ describe BinData::Choice, "with single values" do
     obj.assign(254)
 
     obj.clear
-    obj.must_equal 0
+    _(obj).must_equal 0
   end
 
   it "clears all possible choices" do
@@ -166,7 +166,7 @@ describe BinData::Choice, "with single values" do
     obj.clear
 
     obj.choice = 3
-    obj.must_equal 0
+    _(obj).must_equal 0
   end
 
   it "is clear on initialisation" do
@@ -187,15 +187,15 @@ describe BinData::Choice, "with single values" do
     obj.assign(254)
 
     obj.choice = 7
-    obj.wont_equal 254
+    _(obj).wont_equal 254
   end
 
   it "behaves as value" do
     obj.choice = 3
     obj.assign(5)
 
-    (obj + 1).must_equal 6
-    (1 + obj).must_equal 6
+    _((obj + 1)).must_equal 6
+    _((1 + obj)).must_equal 6
   end
 end
 
@@ -210,7 +210,7 @@ describe BinData::Choice, "with copy_on_change => true" do
     obj.assign(254)
 
     obj.choice = 7
-    obj.must_equal 254
+    _(obj).must_equal 254
   end
 end
 
@@ -219,12 +219,12 @@ describe BinData::Choice, "with :default" do
 
   it "selects for existing case" do
     obj = BinData::Choice.new(selection: "a", choices: choices)
-    obj.num_bytes.must_equal 1
+    _(obj.num_bytes).must_equal 1
   end
 
   it "selects for default case" do
     obj = BinData::Choice.new(selection: "other", choices: choices)
-    obj.num_bytes.must_equal 2
+    _(obj.num_bytes).must_equal 2
   end
 end
 
@@ -240,16 +240,16 @@ describe BinData::Choice, "subclassed with default parameters" do
 
   it "sets initial selection" do
     obj = DerivedChoice.new
-    obj.num_bytes.must_equal 2
+    _(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
+    _(obj.num_bytes).must_equal 4
   end
 
   it "selects default selection" do
     obj = DerivedChoice.new(selection: 'z')
-    obj.num_bytes.must_equal 8
+    _(obj.num_bytes).must_equal 8
   end
 end

data/test/count_bytes_remaining_test.rb

@@ -6,35 +6,35 @@ describe BinData::CountBytesRemaining do
   let(:obj) { BinData::CountBytesRemaining.new }
 
   it "initial state" do
-    obj.must_equal 0
-    obj.num_bytes.must_equal 0
+    _(obj).must_equal 0
+    _(obj.num_bytes).must_equal 0
   end
 
   it "counts till end of stream" do
     data = "abcdefghij"
-    obj.read(data).must_equal 10
+    _(obj.read(data)).must_equal 10
   end
 
   it "does not read any data" do
     io = StringIO.new "abcdefghij"
     obj.read(io)
 
-    io.pos.must_equal 0
+    _(io.pos).must_equal 0
   end
 
   it "does not write any data" do
-    obj.to_binary_s.must_equal_binary ""
+    _(obj.to_binary_s).must_equal_binary ""
   end
 
   it "allows setting value for completeness" do
     obj.assign("123")
-    obj.must_equal "123"
-    obj.to_binary_s.must_equal_binary ""
+    _(obj).must_equal "123"
+    _(obj.to_binary_s).must_equal_binary ""
   end
 
   it "accepts BinData::BasePrimitive parameters" do
     count = BinData::CountBytesRemaining.new(assert: 2)
-    lambda {
+    _ {
       count.read("xyz")
     }.must_raise BinData::ValidityError
   end

data/test/delayed_io_test.rb

@@ -6,26 +6,26 @@ describe BinData::DelayedIO, "when instantiating" do
   describe "with no mandatory parameters supplied" do
     it "raises an error" do
       args = {}
-      lambda { BinData::DelayedIO.new(args) }.must_raise ArgumentError
+      _ { BinData::DelayedIO.new(args) }.must_raise ArgumentError
     end
   end
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
       args = {read_abs_offset: 3}
-      lambda { BinData::DelayedIO.new(args) }.must_raise ArgumentError
+      _ { BinData::DelayedIO.new(args) }.must_raise ArgumentError
     end
   end
 
   it "fails if a given type is unknown" do
     args = {type: :does_not_exist, length: 3}
-    lambda { BinData::DelayedIO.new(args) }.must_raise BinData::UnRegisteredTypeError
+    _ { BinData::DelayedIO.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "accepts BinData::Base as :type" do
     obj = BinData::Int8.new(initial_value: 5)
     array = BinData::DelayedIO.new(type: obj, read_abs_offset: 3)
-    array.must_equal 5
+    _(array).must_equal 5
   end
 end
 
@@ -39,7 +39,7 @@ describe BinData::DelayedIO, "subclassed with a single type" do
 
   it "behaves as type" do
     obj = IntDelayedIO.new(3)
-    obj.must_equal 3
+    _(obj).must_equal 3
   end
 
   it "does not read" do
@@ -49,37 +49,37 @@ describe BinData::DelayedIO, "subclassed with a single type" do
 
   it "does not do_num_bytes" do
     obj = IntDelayedIO.new(3)
-    obj.do_num_bytes.must_equal 0
+    _(obj.do_num_bytes).must_equal 0
   end
 
   it "does num_bytes" do
     obj = IntDelayedIO.new(3)
-    obj.num_bytes.must_equal 2
+    _(obj.num_bytes).must_equal 2
   end
 
   it "does not write" do
     io = StringIO.new
     obj = IntDelayedIO.new(3)
     obj.write(io)
-    io.value.must_equal ""
+    _(io.value).must_equal ""
   end
 
   it "uses read_abs_offset" do
     obj = IntDelayedIO.new(3)
-    obj.abs_offset.must_equal 5
-    obj.rel_offset.must_equal 5
+    _(obj.abs_offset).must_equal 5
+    _(obj.rel_offset).must_equal 5
   end
 
   it "uses abs_offset if set" do
     obj = IntDelayedIO.new(3)
     obj.abs_offset = 10
-    obj.abs_offset.must_equal 10
-    obj.rel_offset.must_equal 10
+    _(obj.abs_offset).must_equal 10
+    _(obj.rel_offset).must_equal 10
   end
 
   it "must call #read before #read_now!" do
     obj = IntDelayedIO.new(3)
-    lambda {
+    _ {
       obj.read_now!
     }.must_raise IOError
   end
@@ -88,12 +88,12 @@ describe BinData::DelayedIO, "subclassed with a single type" do
     obj = IntDelayedIO.read "\001\002\003\004\005\006\007"
     obj.read_now!
 
-    obj.must_equal 0x0607
+    _(obj).must_equal 0x0607
   end
 
   it "must call #write before #write_now!" do
     obj = IntDelayedIO.new(3)
-    lambda {
+    _ {
       obj.write_now!
     }.must_raise IOError
   end
@@ -103,7 +103,7 @@ describe BinData::DelayedIO, "subclassed with a single type" do
     obj = IntDelayedIO.new(3)
     obj.write(io)
     obj.write_now!
-    io.value.must_equal "\001\002\003\004\005\000\003\010\011"
+    _(io.value).must_equal "\001\002\003\004\005\000\003\010\011"
   end
 
   it "writes explicitly after setting abs_offset" do
@@ -113,7 +113,7 @@ describe BinData::DelayedIO, "subclassed with a single type" do
 
     obj.abs_offset = 1
     obj.write_now!
-    io.value.must_equal "\001\000\007\004\005\006\007\010\011"
+    _(io.value).must_equal "\001\000\007\004\005\006\007\010\011"
   end
 end
 
@@ -128,14 +128,14 @@ describe BinData::DelayedIO, "subclassed with multiple types" do
 
   it "behaves as type" do
     obj = StringDelayedIO.new(str: "hello")
-    obj.snapshot.must_equal({len: 5, str: "hello"})
+    _(obj.snapshot).must_equal({len: 5, str: "hello"})
   end
 
   it "reads explicitly" do
     obj = StringDelayedIO.read "\001\002\003\004\005\000\003abc\013"
     obj.read_now!
 
-    obj.snapshot.must_equal({len: 3, str: "abc"})
+    _(obj.snapshot).must_equal({len: 3, str: "abc"})
   end
 
   it "writes explicitly" do
@@ -143,7 +143,7 @@ describe BinData::DelayedIO, "subclassed with multiple types" do
     obj = StringDelayedIO.new(str: "hello")
     obj.write(io)
     obj.write_now!
-    io.value.must_equal "\001\002\003\004\005\000\005hello\015"
+    _(io.value).must_equal "\001\002\003\004\005\000\005hello\015"
   end
 end
 
@@ -162,16 +162,16 @@ describe BinData::DelayedIO, "inside a Record" do
 
   it "reads" do
     obj = DelayedIORecord.read "\x05\x00\x03\x0012345"
-    obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({str_length: 0, str: "", my_int: 7})
+    _(obj.num_bytes).must_equal 2
+    _(obj.snapshot).must_equal({str_length: 0, str: "", my_int: 7})
   end
 
   it "reads explicitly" do
     obj = DelayedIORecord.read "\x05\x00\x03\x0012345"
     obj.str.read_now!
     obj.my_int.read_now!
-    obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({str_length: 5, str: "12345", my_int: 3})
+    _(obj.num_bytes).must_equal 2
+    _(obj.snapshot).must_equal({str_length: 5, str: "12345", my_int: 3})
   end
 
   it "writes" do
@@ -180,7 +180,52 @@ describe BinData::DelayedIO, "inside a Record" do
     obj.write(io)
     obj.str.write_now!
     obj.my_int.write_now!
-    io.value.must_equal "\x03\x00\x02\x00abc"
+    _(io.value).must_equal "\x03\x00\x02\x00abc"
+  end
+end
+
+describe BinData::DelayedIO, "inside a Record with onlyif" do
+  class DelayedIOOnlyIfRecord < BinData::Record
+    endian :little
+
+    uint8 :flag
+    delayed_io :my_int1, read_abs_offset: 4, onlyif: -> { flag != 0 } do
+      uint16 initial_value: 6
+    end
+    delayed_io :my_int2, read_abs_offset: 2, onlyif: -> { flag == 0 } do
+      uint16 initial_value: 7
+    end
+  end
+
+  it "reads" do
+    obj = DelayedIOOnlyIfRecord.read "\x01\x00\x03\x0012345"
+    _(obj.num_bytes).must_equal 1
+    _(obj.snapshot).must_equal({flag: 1, my_int1: 6})
+  end
+
+  it "reads explicitly when flag is set" do
+    obj = DelayedIOOnlyIfRecord.read "\x01\xff\x01\x00\x02\x00"
+    obj.my_int1.read_now!
+    obj.my_int2.read_now!
+    _(obj.num_bytes).must_equal 1
+    _(obj.snapshot).must_equal({flag: 1, my_int1: 2})
+  end
+
+  it "reads explicitly when flag is not set" do
+    obj = DelayedIOOnlyIfRecord.read "\x00\xff\x01\x00\x02\x00"
+    obj.my_int1.read_now!
+    obj.my_int2.read_now!
+    _(obj.num_bytes).must_equal 1
+    _(obj.snapshot).must_equal({flag: 0, my_int2: 1})
+  end
+
+  it "writes" do
+    obj = DelayedIOOnlyIfRecord.new(flag:1, my_int1: 3, my_int2: 4)
+    io = StringIO.new
+    obj.write(io)
+    obj.my_int1.write_now!
+    obj.my_int2.write_now!
+    _(io.value).must_equal "\x01\x00\x00\x00\x03\x00"
   end
 end
 
@@ -195,29 +240,45 @@ describe BinData::DelayedIO, "with auto_call" do
 
   it "class reads" do
     obj = AutoCallDelayedIORecord.read "\x01\x02"
-    obj.snapshot.must_equal({a: 1, b: 2})
+    _(obj.snapshot).must_equal({a: 1, b: 2})
   end
 
   it "reads" do
     obj = AutoCallDelayedIORecord.new
     obj.read "\x01\x02"
-    obj.snapshot.must_equal({a: 1, b: 2})
+    _(obj.snapshot).must_equal({a: 1, b: 2})
   end
 
   it "writes" do
     obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
     io = StringIO.new
     obj.write(io)
-    io.value.must_equal "\x01\x02"
+    _(io.value).must_equal "\x01\x02"
   end
 
   it "to_binary_s" do
     obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
-    obj.to_binary_s.must_equal_binary "\x01\x02"
+    _(obj.to_binary_s).must_equal_binary "\x01\x02"
   end
 
   it "num_bytes" do
     obj = AutoCallDelayedIORecord.new(a: 1, b: 2)
-    obj.num_bytes.must_equal 2
+    _(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