bindata 2.4.10 → 2.5.0

data/test/base_primitive_test.rb

@@ -24,7 +24,7 @@ end
 
 describe BinData::BasePrimitive do
   it "is not registered" do
-    lambda {
+    _ {
       BinData::RegisteredClasses.lookup("BasePrimitive")
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -38,9 +38,9 @@ describe BinData::BasePrimitive, "all subclasses" do
   let(:obj) { SubClassOfBasePrimitive.new }
 
   it "raise errors on unimplemented methods" do
-    lambda { obj.value_to_binary_string(nil) }.must_raise NotImplementedError
-    lambda { obj.read_and_return_value(nil) }.must_raise NotImplementedError
-    lambda { obj.sensible_default }.must_raise NotImplementedError
+    _ { obj.value_to_binary_string(nil) }.must_raise NotImplementedError
+    _ { obj.read_and_return_value(nil) }.must_raise NotImplementedError
+    _ { obj.sensible_default }.must_raise NotImplementedError
   end
 end
 
@@ -48,53 +48,53 @@ describe ExampleSingle do
   let(:obj) { ExampleSingle.new(5) }
 
   it "fails when assigning nil values" do
-    lambda { obj.assign(nil) }.must_raise ArgumentError
+    _ { obj.assign(nil) }.must_raise ArgumentError
   end
 
   it "sets and retrieves values" do
     obj.assign(7)
-    obj.must_equal 7
+    _(obj).must_equal 7
   end
 
   it "sets and retrieves BinData::BasePrimitives" do
     obj.assign(ExampleSingle.new(7))
-    obj.must_equal 7
+    _(obj).must_equal 7
   end
 
   it "responds to known methods" do
-    obj.must_respond_to :num_bytes
+    _(obj).must_respond_to :num_bytes
   end
 
   it "responds to known methods in #snapshot" do
-    obj.must_respond_to :div
+    _(obj).must_respond_to :div
   end
 
   it "does not respond to unknown methods in self or #snapshot" do
-    obj.wont_respond_to :does_not_exist
+    _(obj).wont_respond_to :does_not_exist
   end
 
   it "behaves as #snapshot" do
-    (obj + 1).must_equal 6
-    (1 + obj).must_equal 6
+    _((obj + 1)).must_equal 6
+    _((1 + obj)).must_equal 6
   end
 
   it "is equal to other ExampleSingle" do
-    obj.must_equal ExampleSingle.new(5)
+    _(obj).must_equal ExampleSingle.new(5)
   end
 
   it "is equal to raw values" do
-    obj.must_equal 5
-    5.must_equal obj
+    _(obj).must_equal 5
+    _(5).must_equal obj
   end
 
   it "can be used as a hash key" do
     hash = {5 => 17}
 
-    hash[obj].must_equal 17
+    _(hash[obj]).must_equal 17
   end
 
   it "is sortable" do
-    [ExampleSingle.new(5), ExampleSingle.new(3)].sort.must_equal [3, 5]
+    _([ExampleSingle.new(5), ExampleSingle.new(3)].sort).must_equal [3, 5]
   end
 end
 
@@ -103,25 +103,25 @@ describe BinData::BasePrimitive, "after initialisation" do
 
   it "does not allow both :initial_value and :value" do
     params = {initial_value: 1, value: 2}
-    lambda { ExampleSingle.new(params) }.must_raise ArgumentError
+    _ { ExampleSingle.new(params) }.must_raise ArgumentError
   end
 
   it "initial state" do
     assert obj.clear?
-    obj.value.must_equal 0
-    obj.num_bytes.must_equal 4
+    _(obj.value).must_equal 0
+    _(obj.num_bytes).must_equal 4
   end
 
   it "has symmetric IO" do
     obj.assign(42)
     written = obj.to_binary_s
 
-    ExampleSingle.read(written).must_equal 42
+    _(ExampleSingle.read(written)).must_equal 42
   end
 
   it "sets and retrieves values" do
     obj.value = 5
-    obj.value.must_equal 5
+    _(obj.value).must_equal 5
   end
 
   it "is not clear after setting value" do
@@ -136,7 +136,7 @@ describe BinData::BasePrimitive, "after initialisation" do
 
   it "returns a snapshot" do
     obj.assign(5)
-    obj.snapshot.must_equal 5
+    _(obj.snapshot).must_equal 5
   end
 end
 
@@ -144,23 +144,23 @@ describe BinData::BasePrimitive, "with :initial_value" do
   let(:obj) { ExampleSingle.new(initial_value: 5) }
 
   it "initial state" do
-    obj.value.must_equal 5
+    _(obj.value).must_equal 5
   end
 
   it "forgets :initial_value after being set" do
     obj.assign(17)
-    obj.wont_equal 5
+    _(obj).wont_equal 5
   end
 
   it "forgets :initial_value after reading" do
     obj.read("\x11\x22\x33\x44")
-    obj.wont_equal 5
+    _(obj).wont_equal 5
   end
 
   it "remembers :initial_value after being cleared" do
     obj.assign(17)
     obj.clear
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 end
 
@@ -169,24 +169,24 @@ describe BinData::BasePrimitive, "with :value" do
   let(:io)  { ExampleSingle.io_with_value(56) }
 
   it "initial state" do
-    obj.value.must_equal 5
+    _(obj.value).must_equal 5
   end
 
   it "changes during reading" do
     obj.read(io)
     obj.stub :reading?, true do
-      obj.must_equal 56
+      _(obj).must_equal 56
     end
   end
 
   it "does not change after reading" do
     obj.read(io)
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 
   it "is unaffected by assigning" do
     obj.assign(17)
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 end
 
@@ -197,18 +197,18 @@ describe BinData::BasePrimitive, "asserting value" do
     it "asserts sensible value" do
       data = ExampleSingle.new(assert: 0)
       data.assert!
-      data.value.must_equal 0
+      _(data.value).must_equal 0
     end
 
     it "succeeds when assert is correct" do
       data = ExampleSingle.new(assert: 12)
       data.read(io)
-      data.value.must_equal 12
+      _(data.value).must_equal 12
     end
 
     it "fails when assert is incorrect" do
       data = ExampleSingle.new(assert: -> { 99 })
-      lambda { data.read(io) }.must_raise BinData::ValidityError
+      _ { data.read(io) }.must_raise BinData::ValidityError
     end
   end
 
@@ -216,12 +216,12 @@ describe BinData::BasePrimitive, "asserting value" do
     it "succeeds when assert is true" do
       data = ExampleSingle.new(assert: -> { value < 20 })
       data.read(io)
-      data.value.must_equal 12
+      _(data.value).must_equal 12
     end
 
     it "fails when assert is false" do
       data = ExampleSingle.new(assert: -> { value > 20 })
-      lambda { data.read(io) }.must_raise BinData::ValidityError
+      _ { data.read(io) }.must_raise BinData::ValidityError
     end
   end
 
@@ -229,12 +229,12 @@ describe BinData::BasePrimitive, "asserting value" do
     it "succeeds when assert is correct" do
       data = ExampleSingle.new(assert: 12)
       data.assign(12)
-      data.value.must_equal 12
+      _(data.value).must_equal 12
     end
 
     it "fails when assert is incorrect" do
       data = ExampleSingle.new(assert: 12)
-      lambda { data.assign(99) }.must_raise BinData::ValidityError
+      _ { data.assign(99) }.must_raise BinData::ValidityError
     end
   end
 end
@@ -242,19 +242,19 @@ end
 describe BinData::BasePrimitive, ":asserted_value" do
   it "has :value" do
     data = ExampleSingle.new(asserted_value: -> { 12 })
-    data.value.must_equal 12
+    _(data.value).must_equal 12
   end
 
   describe "assigning with :assert" do
     it "succeeds when assert is correct" do
       data = ExampleSingle.new(asserted_value: -> { 12 })
       data.assign(12)
-      data.value.must_equal 12
+      _(data.value).must_equal 12
     end
 
     it "fails when assert is incorrect" do
       data = ExampleSingle.new(asserted_value: -> { 12 })
-      lambda { data.assign(99) }.must_raise BinData::ValidityError
+      _ { data.assign(99) }.must_raise BinData::ValidityError
     end
   end
 end
@@ -262,7 +262,7 @@ end
 describe BinData::BasePrimitive do
   it "conforms to rule 1 for returning a value" do
     data = ExampleSingle.new(value: 5)
-    data.must_equal 5
+    _(data).must_equal 5
   end
 
   it "conforms to rule 2 for returning a value" do
@@ -271,34 +271,34 @@ describe BinData::BasePrimitive do
     data.read(io)
 
     data.stub :reading?, true do
-      data.must_equal 42
+      _(data).must_equal 42
     end
   end
 
   it "conforms to rule 3 for returning a value" do
     data = ExampleSingle.new(initial_value: 5)
     assert data.clear?
-    data.must_equal 5
+    _(data).must_equal 5
   end
 
   it "conforms to rule 4 for returning a value" do
     data = ExampleSingle.new(initial_value: 5)
     data.assign(17)
     refute data.clear?
-    data.must_equal 17
+    _(data).must_equal 17
   end
 
   it "conforms to rule 5 for returning a value" do
     data = ExampleSingle.new
     assert data.clear?
-    data.must_equal 0
+    _(data).must_equal 0
   end
 
   it "conforms to rule 6 for returning a value" do
     data = ExampleSingle.new
     data.assign(8)
     refute data.clear?
-    data.must_equal 8
+    _(data).must_equal 8
   end
 end
 

data/test/base_test.rb

@@ -28,23 +28,23 @@ describe "BinData::Base", "framework" do
   end
 
   it "raises errors on unimplemented methods" do
-    lambda { obj.clear?        }.must_raise NotImplementedError
-    lambda { obj.assign(nil)   }.must_raise NotImplementedError
-    lambda { obj.snapshot      }.must_raise NotImplementedError
-    lambda { obj.do_read(nil)  }.must_raise NotImplementedError
-    lambda { obj.do_write(nil) }.must_raise NotImplementedError
-    lambda { obj.do_num_bytes  }.must_raise NotImplementedError
+    _ { obj.clear?        }.must_raise NotImplementedError
+    _ { obj.assign(nil)   }.must_raise NotImplementedError
+    _ { obj.snapshot      }.must_raise NotImplementedError
+    _ { obj.do_read(nil)  }.must_raise NotImplementedError
+    _ { obj.do_write(nil) }.must_raise NotImplementedError
+    _ { obj.do_num_bytes  }.must_raise NotImplementedError
   end
 
   it "calls initialize methods in order" do
     FrameworkBase.record_calls { FrameworkBase.new }
-    FrameworkBase.calls.must_equal [:initialize_shared_instance, :initialize_instance]
+    _(FrameworkBase.calls).must_equal [:initialize_shared_instance, :initialize_instance]
   end
 
   it "does not call #initialize_shared_instance for prototypes" do
     prototype = obj
     FrameworkBase.record_calls { prototype.new }
-    FrameworkBase.calls.must_equal [:initialize_instance]
+    _(FrameworkBase.calls).must_equal [:initialize_instance]
   end
 end
 
@@ -72,9 +72,9 @@ describe BinData::Base, "ArgExtractor" do
     data.each do |el|
       args, val, param_keys, parent = *el
       obj = ParamParserBase.new(*args)
-      obj.val.must_be_same_as val
-      obj.params.keys.must_equal param_keys
-      obj.parent.must_be_same_as parent
+      _(obj.val).must_be_same_as val
+      _(obj.params.keys).must_equal param_keys
+      _(obj.parent).must_be_same_as parent
     end
   end
 end
@@ -93,36 +93,36 @@ describe BinData::Base do
   let(:obj) { BaseStub.new }
 
   it "::bindata_name returns lowercased name" do
-    BaseStub.bindata_name.must_equal "base_stub"
+    _(BaseStub.bindata_name).must_equal "base_stub"
   end
 
   it "::read instantiates self" do
-    BaseStub.read("").must_be_instance_of BaseStub
+    _(BaseStub.read("")).must_be_instance_of BaseStub
   end
 
   it "#read returns self" do
-    obj.read("").must_equal obj
+    _(obj.read("")).must_equal obj
   end
 
   it "#write returns self" do
-    obj.write("").must_equal obj
+    _(obj.write("")).must_equal obj
   end
 
   it "#to_hex uses #to_binary_s representation" do
     obj.stub :to_binary_s, "\x01\xab\xCD" do
-      obj.to_hex.must_equal "01abcd"
+      _(obj.to_hex).must_equal "01abcd"
     end
   end
 
   it "#inspect is forwarded to snapshot" do
     obj.stub :snapshot, [1, 2, 3] do
-      obj.inspect.must_equal obj.snapshot.inspect
+      _(obj.inspect).must_equal obj.snapshot.inspect
     end
   end
 
   it "#to_s is forwarded to snapshot" do
     obj.stub :snapshot, [1, 2, 3] do
-      obj.to_s.must_equal obj.snapshot.to_s
+      _(obj.to_s).must_equal obj.snapshot.to_s
     end
   end
 
@@ -136,7 +136,7 @@ describe BinData::Base do
       PP.pp(obj.snapshot, expected_io)
     end
 
-    actual_io.value.must_equal expected_io.value
+    _(actual_io.value).must_equal expected_io.value
   end
 
   it "#write writes the same as #to_binary_s" do
@@ -147,7 +147,7 @@ describe BinData::Base do
     obj = WriteToSBase.new
     io = StringIO.new
     obj.write(io)
-    io.value.must_equal obj.to_binary_s
+    _(io.value).must_equal obj.to_binary_s
   end
 
   it "#read is forwarded to #do_read" do
@@ -161,7 +161,7 @@ describe BinData::Base do
       end
     end
 
-    calls.must_equal [:clear, :do_read]
+    _(calls).must_equal [:clear, :do_read]
   end
 
   it "#write is forwarded to #do_write" do
@@ -172,18 +172,18 @@ describe BinData::Base do
       obj.write(nil)
     end
 
-    calls.must_equal [:do_write]
+    _(calls).must_equal [:do_write]
   end
 
   it "#num_bytes is forwarded to #do_num_bytes" do
     obj.stub :do_num_bytes, 42 do
-      obj.num_bytes.must_equal 42
+      _(obj.num_bytes).must_equal 42
     end
   end
 
   it "#num_bytes rounds up fractional values" do
     obj.stub :do_num_bytes, 42.1 do
-      obj.num_bytes.must_equal 43
+      _(obj.num_bytes).must_equal 43
     end
   end
 end

data/test/bits_test.rb

@@ -6,21 +6,21 @@ module AllBitfields
 
   def test_has_a_sensible_value_of_zero
     all_objects do |obj, nbits|
-      obj.must_equal 0
+      _(obj).must_equal 0
     end
   end
 
   def test_avoids_underflow
     all_objects do |obj, nbits|
       obj.assign(min_value - 1)
-      obj.must_equal min_value
+      _(obj).must_equal min_value
     end
   end
 
   def test_avoids_overflow
     all_objects do |obj, nbits|
       obj.assign(max_value + 1)
-      obj.must_equal max_value
+      _(obj).must_equal max_value
     end
   end
 
@@ -28,7 +28,7 @@ module AllBitfields
     all_objects do |obj, nbits|
       some_values_within_range.each do |val|
         obj.assign(val)
-        obj.must_equal val
+        _(obj).must_equal val
       end
     end
   end
@@ -37,7 +37,7 @@ module AllBitfields
     all_objects do |obj, nbits|
       some_values_within_range.each do |val|
         obj.assign(obj.new(val))
-        obj.must_equal val
+        _(obj).must_equal val
       end
     end
   end
@@ -48,7 +48,7 @@ module AllBitfields
         obj.assign(val)
         other = obj.new
         other.read(obj.to_binary_s)
-        other.must_equal obj
+        _(other).must_equal obj
       end
     end
   end
@@ -130,7 +130,7 @@ describe "Unsigned big endian bitfields" do
       str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
 
       obj.read(str)
-      obj.must_equal 1 << (nbits - 1)
+      _(obj).must_equal 1 << (nbits - 1)
     end
   end
 end
@@ -149,7 +149,7 @@ describe "Signed big endian bitfields" do
       str = [0b0100_0000].pack("C") + "\000" * (nbytes - 1)
 
       obj.read(str)
-      obj.must_equal 1 << (nbits - 2)
+      _(obj).must_equal 1 << (nbits - 2)
     end
   end
 end
@@ -168,7 +168,7 @@ describe "Unsigned little endian bitfields" do
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
       obj.read(str)
-      obj.must_equal 1
+      _(obj).must_equal 1
     end
   end
 end
@@ -187,7 +187,7 @@ describe "Signed little endian bitfields" do
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
       obj.read(str)
-      obj.must_equal 1
+      _(obj).must_equal 1
     end
   end
 end
@@ -199,7 +199,7 @@ describe "Bits of size 1" do
     bit_classes.each do |bit_class|
       obj = bit_class.new
       obj.assign(true)
-      obj.must_equal 1
+      _(obj).must_equal 1
     end
   end
 
@@ -207,7 +207,7 @@ describe "Bits of size 1" do
     bit_classes.each do |bit_class|
       obj = bit_class.new
       obj.assign(false)
-      obj.must_equal 0
+      _(obj).must_equal 0
     end
   end
 
@@ -215,16 +215,16 @@ describe "Bits of size 1" do
     bit_classes.each do |bit_class|
       obj = bit_class.new
       obj.assign(nil)
-      obj.must_equal 0
+      _(obj).must_equal 0
     end
   end
 
   it "must not be signed" do
-    lambda {
+    _ {
       BinData::Sbit1
     }.must_raise RuntimeError
 
-    lambda {
+    _ {
       BinData::Sbit1le
     }.must_raise RuntimeError
   end