bindata 2.4.10 → 2.4.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 651bb61168cb520dbec6550dc4ee3d566e950a0a4e3c373752a37d9ced6dc17e
-  data.tar.gz: 543f3849f0502255c976520e3d11f2e988f0733314b905d098b8617025ef2d99
+  metadata.gz: 991ca0b6e07c8ef180244a7495796d7da21b1b27091d00b9ab6218c7208251d3
+  data.tar.gz: c72cdce5b44d3a5837d6172271d69ac1a56b1227945bfcb9edce592da9d822c1
 SHA512:
-  metadata.gz: 5ab4ddc205727d64b5b4f1354c6c738965745ff6736030f440c3982799351e68af06c9f1e0faff28d6e52830a0abf55d678a0ea7ffefa160f9f7bf3c309b6e7b
-  data.tar.gz: 834bdfa27436e578043e8b92ded99a02e6fc5ca2d0e11f0503bf3d8d68c1c7c9e491e66fe59f264156fb9675437cc9f014193f42132a8e6aec3a11b6f84f5312
+  metadata.gz: d53ac6de7495ae457d73b642190460adf0b5715c9b9538ad131ab8925f705df4cfa1ccf61c26361654998a9dabd32e0de33cb281954c346f8a724b5ee19249c8
+  data.tar.gz: '089fc03d8e7e8989553aec6b2878d71c41a2bb3ab98f4ba67c680176ff75c243afb48298b7e54abd439c1ff084433850373f5659b4edc058240387fc10a37fa5'

data/ChangeLog.rdoc

@@ -1,5 +1,24 @@
 = BinData Changelog
 
+== Version 2.4.14 (2022-10-31)
+
+* Use Comparable#clamp instead of manual calculations.
+* Update tests to new minitest requirements.
+* Adjust tests due to changes in ruby 3.1
+
+== Version 2.4.13 (2022-10-16)
+
+* Relax over-strict parameter naming requirements.  Requested by
+  vinayak3qilabs.
+
+== Version 2.4.12 (2022-10-03)
+
+* Do not include DelayedIO objects when :onlyif is false.
+
+== Version 2.4.11 (2022-09-27)
+
+* Make DelayedIO work with :onlyif.  Reported by Spencer McIntyre.
+
 == Version 2.4.10 (2021-05-18)
 
 * Improve speed of dynamic object creation.  Reported by Charlie Ablett.

data/lib/bindata/bits.rb

@@ -99,14 +99,14 @@ module BinData
 
       def create_dynamic_clamp_code(signed)
         if signed == :signed
-          max = "max = (1 << (nbits - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (nbits - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          max = "max = (1 << nbits) - 1"
-          min = "min = 0"
+          max = "(1 << nbits) - 1"
+          min = "0"
         end
 
-        "#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_fixed_clamp_code(nbits, signed)
@@ -115,14 +115,14 @@ module BinData
         end
 
         if signed == :signed
-          max = "max = (1 << (#{nbits} - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (#{nbits} - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          min = "min = 0"
-          max = "max = (1 << #{nbits}) - 1"
+          min = "0"
+          max = "(1 << #{nbits}) - 1"
         end
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
+        clamp = "(val = val.clamp(#{min}, #{max}))"
 
         if nbits == 1
           # allow single bits to be used as booleans

data/lib/bindata/delayed_io.rb

@@ -116,9 +116,14 @@ module BinData
       0
     end
 
+    def include_obj?
+      ! has_parameter?(:onlyif) || eval_parameter(:onlyif)
+    end
+
     # DelayedIO objects aren't read when #read is called.
     # The reading is delayed until this method is called.
     def read_now!
+      return unless include_obj?
       raise IOError, "read from where?" unless @read_io
 
       @read_io.seekbytes(abs_offset - @read_io.offset)
@@ -130,7 +135,9 @@ module BinData
     # DelayedIO objects aren't written when #write is called.
     # The writing is delayed until this method is called.
     def write_now!
+      return unless include_obj?
       raise IOError, "write to where?" unless @write_io
+
       @write_io.seekbytes(abs_offset - @write_io.offset)
       @type.do_write(@write_io)
     end

data/lib/bindata/dsl.rb

@@ -420,7 +420,7 @@ module BinData
       def ensure_valid_name(name)
         if name && !option?(:fieldnames_are_values)
           if malformed_name?(name)
-            raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
+            raise SyntaxError, "field '#{name}' is an illegal fieldname"
           end
 
           if duplicate_name?(name)
@@ -428,11 +428,11 @@ module BinData
           end
 
           if name_shadows_method?(name)
-            raise NameError.new("", name), "field '#{name}' shadows an existing method"
+            raise SyntaxError, "field '#{name}' shadows an existing method"
           end
 
           if name_is_reserved?(name)
-            raise NameError.new("", name), "field '#{name}' is a reserved name"
+            raise SyntaxError, "field '#{name}' is a reserved name"
           end
         end
       end

data/lib/bindata/int.rb

@@ -59,16 +59,14 @@ module BinData
 
       def create_clamp_code(nbits, signed)
         if signed == :signed
-          max = "max = (1 << (#{nbits} - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (#{nbits} - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          max = "max = (1 << #{nbits}) - 1"
-          min = "min = 0"
+          max = "(1 << #{nbits}) - 1"
+          min = "0"
         end
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
-
-        "val = #{clamp}"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_read_code(nbits, endian, signed)

data/lib/bindata/params.rb

@@ -116,7 +116,7 @@ module BinData
 
       def self.invalid_parameter_names
         @invalid_names ||= begin
-          all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
+          all_names = LazyEvaluator.instance_methods(true)
           allowed_names = [:name, :type]
           invalid_names = (all_names - allowed_names).uniq
 

data/lib/bindata/struct.rb

@@ -1,4 +1,5 @@
 require 'bindata/base'
+require 'bindata/delayed_io'
 
 module BinData
 
@@ -136,12 +137,12 @@ module BinData
 
     def do_read(io) #:nodoc:
       instantiate_all_objs
-      @field_objs.each { |f| f.do_read(io) if include_obj?(f) }
+      @field_objs.each { |f| f.do_read(io) if include_obj_for_io?(f) }
     end
 
     def do_write(io) #:nodoc
       instantiate_all_objs
-      @field_objs.each { |f| f.do_write(io) if include_obj?(f) }
+      @field_objs.each { |f| f.do_write(io) if include_obj_for_io?(f) }
     end
 
     def do_num_bytes #:nodoc:
@@ -263,6 +264,12 @@ module BinData
       end
     end
 
+    def include_obj_for_io?(obj)
+      # Used by #do_read and #do_write, to ensure the stream is passed to
+      # DelayedIO objects for delayed processing.
+      include_obj?(obj) || DelayedIO === obj
+    end
+
     def include_obj?(obj)
       !obj.has_parameter?(:onlyif) || obj.eval_parameter(:onlyif)
     end

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "2.4.10"
+  VERSION = "2.4.14"
 end

data/test/alignment_test.rb

@@ -14,20 +14,20 @@ describe BinData::ResumeByteAlignment do
   it "resets read alignment" do
     obj.read "\x12\x34"
 
-    obj.a.must_equal 1
-    obj.b.must_equal 3
+    _(obj.a).must_equal 1
+    _(obj.b).must_equal 3
   end
 
   it "resets write alignment" do
     obj.assign(a: 2, b: 7)
 
-    obj.to_binary_s.must_equal_binary "\x20\x70"
+    _(obj.to_binary_s).must_equal_binary "\x20\x70"
   end
 end
 
 describe BinData::BitAligned do
   it "does not apply to BinData::Primitives" do
-    lambda {
+    _ {
       class BitAlignedPrimitive < BinData::Primitive
         bit_aligned
       end
@@ -47,20 +47,20 @@ describe BinData::BitAligned do
   let(:obj) { BitAlignedRecord.new }
 
   it "#num_bytes as expected" do
-    obj.num_bytes.must_equal 3
+    _(obj.num_bytes).must_equal 3
   end
 
   it "has expected abs_offset" do
-    obj.str.abs_offset.must_equal 0
+    _(obj.str.abs_offset).must_equal 0
   end
 
   it "reads as expected" do
     obj.read("\x56\x36\x42")
-    obj.snapshot.must_equal({preamble: 5, str: "cd", afterward: 2})
+    _(obj.snapshot).must_equal({preamble: 5, str: "cd", afterward: 2})
   end
 
   it "writes as expected" do
     obj.assign(preamble: 5, str: "ab", afterward: 1)
-    obj.to_binary_s.must_equal_binary "\x56\x16\x21"
+    _(obj.to_binary_s).must_equal_binary "\x56\x16\x21"
   end
 end

data/test/array_test.rb

@@ -6,14 +6,14 @@ describe BinData::Array, "when instantiating" do
   describe "with no mandatory parameters supplied" do
     it "raises an error" do
       args = {}
-      lambda { BinData::Array.new(args) }.must_raise ArgumentError
+      _ { BinData::Array.new(args) }.must_raise ArgumentError
     end
   end
 
   describe "with some but not all mandatory parameters supplied" do
     it "raises an error" do
       args = {initial_length: 3}
-      lambda { BinData::Array.new(args) }.must_raise ArgumentError
+      _ { BinData::Array.new(args) }.must_raise ArgumentError
     end
   end
 
@@ -33,23 +33,23 @@ describe BinData::Array, "when instantiating" do
 
   it "fails if a given type is unknown" do
     args = {type: :does_not_exist, initial_length: 3}
-    lambda { BinData::Array.new(args) }.must_raise BinData::UnRegisteredTypeError
+    _ { BinData::Array.new(args) }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "fails if :initial_length is not an integer" do
     args = {type: :uint8, initial_length: "3"}
-    lambda { BinData::Array.new(args) }.must_raise ArgumentError
+    _ { BinData::Array.new(args) }.must_raise ArgumentError
   end
 
   it "does not allow both :initial_length and :read_until" do
     args = {initial_length: 3, read_until: -> { false } }
-    lambda { BinData::Array.new(args) }.must_raise ArgumentError
+    _ { BinData::Array.new(args) }.must_raise ArgumentError
   end
 
   it "accepts BinData::Base as :type" do
     obj = BinData::Int8.new(initial_value: 5)
     array = BinData::Array.new(type: obj, initial_length: 1)
-    array.must_equal [5]
+    _(array).must_equal [5]
   end
 end
 
@@ -58,18 +58,18 @@ describe BinData::Array, "with no elements" do
 
   it "initial state" do
     assert obj.clear?
-    obj.must_be_empty
-    obj.length.must_equal 0
-    obj.first.must_be_nil
-    obj.last.must_be_nil
+    _(obj).must_be_empty
+    _(obj.length).must_equal 0
+    _(obj.first).must_be_nil
+    _(obj.last).must_be_nil
   end
 
   it "returns [] for the first n elements" do
-    obj.first(3).must_equal []
+    _(obj.first(3)).must_equal []
   end
 
   it "returns [] for the last n elements" do
-    obj.last(3).must_equal []
+    _(obj.last(3)).must_equal []
   end
 end
 
@@ -81,69 +81,69 @@ describe BinData::Array, "with several elements" do
 
   it "initial state" do
     assert obj.clear?
-    obj.wont_be_empty
-    obj.size.must_equal 5
-    obj.length.must_equal 5
-    obj.snapshot.must_equal [1, 2, 3, 4, 5]
-    obj.inspect.must_equal "[1, 2, 3, 4, 5]"
+    _(obj).wont_be_empty
+    _(obj.size).must_equal 5
+    _(obj.length).must_equal 5
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5]
+    _(obj.inspect).must_equal "[1, 2, 3, 4, 5]"
   end
 
   it "coerces to ::Array if required" do
-    [0].concat(obj).must_equal [0, 1, 2, 3, 4, 5]
+    _([0].concat(obj)).must_equal [0, 1, 2, 3, 4, 5]
   end
 
   it "uses methods from Enumerable" do
-    obj.select { |x| (x % 2) == 0 }.must_equal [2, 4]
+    _(obj.select { |x| (x % 2) == 0 }).must_equal [2, 4]
   end
 
   it "assigns primitive values" do
     obj.assign([4, 5, 6])
-    obj.must_equal [4, 5, 6]
+    _(obj).must_equal [4, 5, 6]
   end
 
   it "assigns bindata objects" do
     obj.assign([BinData::Uint32le.new(4), BinData::Uint32le.new(5), BinData::Uint32le.new(6)])
-    obj.must_equal [4, 5, 6]
+    _(obj).must_equal [4, 5, 6]
   end
 
   it "assigns a bindata array" do
     array = BinData::Array.new([4, 5, 6], type: :uint32le)
     obj.assign(array)
-    obj.must_equal [4, 5, 6]
+    _(obj).must_equal [4, 5, 6]
   end
 
   it "returns the first element" do
-    obj.first.must_equal 1
+    _(obj.first).must_equal 1
   end
 
   it "returns the first n elements" do
-    obj[0...3].must_equal [1, 2, 3]
-    obj.first(3).must_equal [1, 2, 3]
-    obj.first(99).must_equal [1, 2, 3, 4, 5]
+    _(obj[0...3]).must_equal [1, 2, 3]
+    _(obj.first(3)).must_equal [1, 2, 3]
+    _(obj.first(99)).must_equal [1, 2, 3, 4, 5]
   end
 
   it "returns the last element" do
-    obj.last.must_equal 5
-    obj[-1].must_equal 5
+    _(obj.last).must_equal 5
+    _(obj[-1]).must_equal 5
   end
 
   it "returns the last n elements" do
-    obj.last(3).must_equal [3, 4, 5]
-    obj.last(99).must_equal [1, 2, 3, 4, 5]
+    _(obj.last(3)).must_equal [3, 4, 5]
+    _(obj.last(99)).must_equal [1, 2, 3, 4, 5]
 
-    obj[-3, 100].must_equal [3, 4, 5]
+    _(obj[-3, 100]).must_equal [3, 4, 5]
   end
 
   it "clears all" do
     obj[1] = 8
     obj.clear
-    obj.must_equal [1, 2, 3, 4, 5]
+    _(obj).must_equal [1, 2, 3, 4, 5]
   end
 
   it "clears a single element" do
     obj[1] = 8
     obj[1].clear
-    obj[1].must_equal 2
+    _(obj[1]).must_equal 2
   end
 
   it "is clear if all elements are clear" do
@@ -160,7 +160,7 @@ describe BinData::Array, "with several elements" do
 
   it "directly accesses elements" do
     obj[1] = 8
-    obj[1].must_equal 8
+    _(obj[1]).must_equal 8
   end
 
   it "symmetrically reads and writes" do
@@ -168,34 +168,34 @@ describe BinData::Array, "with several elements" do
     str = obj.to_binary_s
 
     obj.clear
-    obj[1].must_equal 2
+    _(obj[1]).must_equal 2
 
     obj.read(str)
-    obj[1].must_equal 8
+    _(obj[1]).must_equal 8
   end
 
   it "identifies index of elements" do
-    obj.index(3).must_equal 2
+    _(obj.index(3)).must_equal 2
   end
 
   it "returns nil for index of non existent element" do
-    obj.index(42).must_be_nil
+    _(obj.index(42)).must_be_nil
   end
 
   it "has correct debug name" do
-    obj[2].debug_name.must_equal "obj[2]"
+    _(obj[2].debug_name).must_equal "obj[2]"
   end
 
   it "has correct offset" do
-    obj[2].rel_offset.must_equal 2 * 4
+    _(obj[2].rel_offset).must_equal 2 * 4
   end
 
   it "has correct num_bytes" do
-    obj.num_bytes.must_equal 5 * 4
+    _(obj.num_bytes).must_equal 5 * 4
   end
 
   it "has correct num_bytes for individual elements" do
-    obj[0].num_bytes.must_equal 4
+    _(obj[0].num_bytes).must_equal 4
   end
 end
 
@@ -209,67 +209,67 @@ describe BinData::Array, "when accessing elements" do
 
   it "inserts with positive indexes" do
     obj.insert(2, 30, 40)
-    obj.snapshot.must_equal [1, 2, 30, 40, 3, 4, 5]
+    _(obj.snapshot).must_equal [1, 2, 30, 40, 3, 4, 5]
   end
 
   it "inserts with negative indexes" do
     obj.insert(-2, 30, 40)
-    obj.snapshot.must_equal [1, 2, 3, 4, 30, 40, 5]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 30, 40, 5]
   end
 
   it "pushes" do
     obj.push(30, 40)
-    obj.snapshot.must_equal [1, 2, 3, 4, 5, 30, 40]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5, 30, 40]
   end
 
   it "concats" do
     obj.concat([30, 40])
-    obj.snapshot.must_equal [1, 2, 3, 4, 5, 30, 40]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5, 30, 40]
   end
 
   it "unshifts" do
     obj.unshift(30, 40)
-    obj.snapshot.must_equal [30, 40, 1, 2, 3, 4, 5]
+    _(obj.snapshot).must_equal [30, 40, 1, 2, 3, 4, 5]
   end
 
   it "automatically extends on [index]" do
-    obj[9].must_equal 10
-    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    _(obj[9]).must_equal 10
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   end
 
   it "automatically extends on []=" do
     obj[9] = 30
-    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
   end
 
   it "automatically extends on insert" do
     obj.insert(7, 30, 40)
-    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 30, 40]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5, 6, 7, 30, 40]
   end
 
   it "does not extend on at" do
-    obj.at(9).must_be_nil
-    obj.length.must_equal 5
+    _(obj.at(9)).must_be_nil
+    _(obj.length).must_equal 5
   end
 
   it "does not extend on [start, length]" do
-    obj[9, 2].must_be_nil
-    obj.length.must_equal 5
+    _(obj[9, 2]).must_be_nil
+    _(obj.length).must_equal 5
   end
 
   it "does not extend on [range]" do
-    obj[9 .. 10].must_be_nil
-    obj.length.must_equal 5
+    _(obj[9 .. 10]).must_be_nil
+    _(obj.length).must_equal 5
   end
 
   it "raises error on bad input to []" do
-    lambda { obj["a"] }.must_raise TypeError
-    lambda { obj[1, "a"] }.must_raise TypeError
+    _ { obj["a"] }.must_raise TypeError
+    _ { obj[1, "a"] }.must_raise TypeError
   end
 
   it "is unaffected by self assignment" do
     obj.assign(obj)
-    obj.snapshot.must_equal [1, 2, 3, 4, 5]
+    _(obj.snapshot).must_equal [1, 2, 3, 4, 5]
   end
 end
 
@@ -281,7 +281,7 @@ describe BinData::Array, "with :read_until" do
       obj = BinData::Array.new(type: :int8, read_until: read_until)
 
       obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
-      obj.must_equal [1, 2, 3, 4, 5]
+      _(obj).must_equal [1, 2, 3, 4, 5]
     end
   end
 
@@ -291,7 +291,7 @@ describe BinData::Array, "with :read_until" do
       obj = BinData::Array.new(type: :int8, read_until: read_until)
 
       obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
-      obj.must_equal [1, 2, 3, 4, 5, 6, 7]
+      _(obj).must_equal [1, 2, 3, 4, 5, 6, 7]
     end
   end
 
@@ -300,20 +300,20 @@ describe BinData::Array, "with :read_until" do
       obj = BinData::Array.new(type: :int8, read_until: :eof)
 
       obj.read "\x01\x02\x03"
-      obj.must_equal [1, 2, 3]
+      _(obj).must_equal [1, 2, 3]
     end
 
     it "reads records until eof, ignoring partial records" do
       obj = BinData::Array.new(type: :int16be, read_until: :eof)
 
       obj.read "\x00\x01\x00\x02\x03"
-      obj.must_equal [1, 2]
+      _(obj).must_equal [1, 2]
     end
 
     it "reports exceptions" do
       array_type = [:string, {read_length: -> { unknown_variable }}]
       obj = BinData::Array.new(type: array_type, read_until: :eof)
-      lambda { obj.read "\x00\x01\x00\x02\x03" }.must_raise NoMethodError
+      _ { obj.read "\x00\x01\x00\x02\x03" }.must_raise NoMethodError
     end
   end
 end
@@ -327,12 +327,12 @@ describe BinData::Array, "nested within an Array" do
   }
 
   it "#snapshot" do
-    obj.snapshot.must_equal [ [0], [0, 1], [0, 1, 2] ]
+    _(obj.snapshot).must_equal [ [0], [0, 1], [0, 1, 2] ]
   end
 
   it "maintains structure when reading" do
     obj.read "\x04\x05\x06\x07\x08\x09"
-    obj.must_equal [ [4], [5, 6], [7, 8, 9] ]
+    _(obj).must_equal [ [4], [5, 6], [7, 8, 9] ]
   end
 end
 
@@ -346,12 +346,12 @@ describe BinData::Array, "subclassed" do
 
   it "forwards parameters" do
     obj = IntArray.new(initial_length: 7)
-    obj.length.must_equal 7
+    _(obj.length).must_equal 7
   end
 
   it "overrides default parameters" do
     obj = IntArray.new(initial_length: 3, initial_element_value: 5)
-    obj.to_binary_s.must_equal_binary "\x00\x05\x00\x05\x00\x05"
+    _(obj.to_binary_s).must_equal_binary "\x00\x05\x00\x05\x00\x05"
   end
 end
 
@@ -361,35 +361,35 @@ describe BinData::Array, "of bits" do
   it "reads" do
     str = [0b0001_0100, 0b1000_1000].pack("CC")
     obj.read(str)
-    obj[0].must_equal  0
-    obj[1].must_equal  0
-    obj[2].must_equal  0
-    obj[3].must_equal  1
-    obj[4].must_equal  0
-    obj[5].must_equal  1
-    obj[6].must_equal  0
-    obj[7].must_equal  0
-    obj[8].must_equal  1
-    obj[9].must_equal  0
-    obj[10].must_equal 0
-    obj[11].must_equal 0
-    obj[12].must_equal 1
-    obj[13].must_equal 0
-    obj[14].must_equal 0
+    _(obj[0]).must_equal  0
+    _(obj[1]).must_equal  0
+    _(obj[2]).must_equal  0
+    _(obj[3]).must_equal  1
+    _(obj[4]).must_equal  0
+    _(obj[5]).must_equal  1
+    _(obj[6]).must_equal  0
+    _(obj[7]).must_equal  0
+    _(obj[8]).must_equal  1
+    _(obj[9]).must_equal  0
+    _(obj[10]).must_equal 0
+    _(obj[11]).must_equal 0
+    _(obj[12]).must_equal 1
+    _(obj[13]).must_equal 0
+    _(obj[14]).must_equal 0
   end
 
   it "writes" do
     obj[3] = 1
-    obj.to_binary_s.must_equal_binary [0b0001_0000, 0b0000_0000].pack("CC")
+    _(obj.to_binary_s).must_equal_binary [0b0001_0000, 0b0000_0000].pack("CC")
   end
 
   it "returns num_bytes" do
-    obj.num_bytes.must_equal 2
+    _(obj.num_bytes).must_equal 2
   end
 
   it "has correct offset" do
-    obj[7].rel_offset.must_equal 0
-    obj[8].rel_offset.must_equal 1
+    _(obj[7].rel_offset).must_equal 0
+    _(obj[8].rel_offset).must_equal 1
   end
 end