bindata 2.4.12 → 2.4.14

data/test/lazy_test.rb

@@ -41,33 +41,33 @@ describe BinData::LazyEvaluator, "with no parents" do
   }
 
   it "evaluates raw value when instantiated" do
-    lazy_eval(5).must_equal 5
+    _(lazy_eval(5)).must_equal 5
   end
 
   it "evaluates raw value" do
-    lazy_eval(5).must_equal 5
+    _(lazy_eval(5)).must_equal 5
   end
 
   it "evaluates value" do
-    lazy_eval(lambda { 5 }).must_equal 5
+    _(lazy_eval(lambda { 5 })).must_equal 5
   end
 
   it "evaluates overrides" do
-    lazy_eval(lambda { o1 }, o1: 'o1').must_equal 'o1'
+    _(lazy_eval(lambda { o1 }, o1: 'o1')).must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
-    lambda { lazy_eval(lambda { unknown }) }.must_raise NameError
-    lambda { lazy_eval(lambda { m1 }) }.must_raise NameError
-    lambda { lazy_eval(lambda { p1 }) }.must_raise NameError
+    _ { lazy_eval(lambda { unknown }) }.must_raise NameError
+    _ { lazy_eval(lambda { m1 }) }.must_raise NameError
+    _ { lazy_eval(lambda { p1 }) }.must_raise NameError
   end
 
   it "does not have a parent" do
-    lazy_eval(lambda { parent }).must_be_nil
+    _(lazy_eval(lambda { parent })).must_be_nil
   end
 
   it "does not resolve #index" do
-    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
+    _ { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end
 
@@ -91,51 +91,51 @@ describe BinData::LazyEvaluator, "with one parent" do
   }
 
   it "evaluates raw value" do
-    lazy_eval(5).must_equal 5
+    _(lazy_eval(5)).must_equal 5
   end
 
   it "evaluates value" do
-    lazy_eval(lambda { 5 }).must_equal 5
+    _(lazy_eval(lambda { 5 })).must_equal 5
   end
 
   it "evaluates overrides before params" do
-    lazy_eval(lambda { p1 }, p1: 'o1').must_equal 'o1'
+    _(lazy_eval(lambda { p1 }, p1: 'o1')).must_equal 'o1'
   end
 
   it "evaluates overrides before methods" do
-    lazy_eval(lambda { m1 }, m1: 'o1').must_equal 'o1'
+    _(lazy_eval(lambda { m1 }, m1: 'o1')).must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
-    lambda { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
+    _ { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
   end
 
   it "resolves parameters in the parent" do
-    lazy_eval(lambda { p1 }).must_equal 'Pp1'
+    _(lazy_eval(lambda { p1 })).must_equal 'Pp1'
   end
 
   it "resolves methods in the parent" do
-    lazy_eval(lambda { m1 }).must_equal 'Pm1'
+    _(lazy_eval(lambda { m1 })).must_equal 'Pm1'
   end
 
   it "invokes methods in the parent" do
-    lazy_eval(lambda { echo(p1, m1) }).must_equal ['Pp1', 'Pm1']
+    _(lazy_eval(lambda { echo(p1, m1) })).must_equal ['Pp1', 'Pm1']
   end
 
   it "invokes private methods in the parent" do
-    lazy_eval(lambda { m2 }).must_equal 'Pm2'
+    _(lazy_eval(lambda { m2 })).must_equal 'Pm2'
   end
 
   it "resolves parameters in preference to methods in the parent" do
-    lazy_eval(lambda { com1 }).must_equal 'PpC'
+    _(lazy_eval(lambda { com1 })).must_equal 'PpC'
   end
 
   it "has a parent" do
-    lazy_eval(lambda { parent }).wont_be_nil
+    _(lazy_eval(lambda { parent })).wont_be_nil
   end
 
   it "does not resolve #index" do
-    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
+    _ { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end
 
@@ -167,58 +167,58 @@ describe BinData::LazyEvaluator, "with nested parents" do
   }
 
   it "accepts symbols as a shortcut to lambdas" do
-    lazy_eval(:p1).must_equal 'Pp1'
-    lazy_eval(:p2).must_equal 'PPp2'
-    lazy_eval(:m1).must_equal 'Pm1'
-    lazy_eval(:m2).must_equal 'PPm2'
+    _(lazy_eval(:p1)).must_equal 'Pp1'
+    _(lazy_eval(:p2)).must_equal 'PPp2'
+    _(lazy_eval(:m1)).must_equal 'Pm1'
+    _(lazy_eval(:m2)).must_equal 'PPm2'
   end
 
   it "does not resolve any unknown methods" do
-    lambda { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
+    _ { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
   end
 
   it "resolves parameters in the parent" do
-    lazy_eval(lambda { p1 }).must_equal 'Pp1'
+    _(lazy_eval(lambda { p1 })).must_equal 'Pp1'
   end
 
   it "resolves methods in the parent" do
-    lazy_eval(lambda { m1 }).must_equal 'Pm1'
+    _(lazy_eval(lambda { m1 })).must_equal 'Pm1'
   end
 
   it "resolves parameters in the parent's parent" do
-    lazy_eval(lambda { p2 }).must_equal 'PPp2'
+    _(lazy_eval(lambda { p2 })).must_equal 'PPp2'
   end
 
   it "resolves methods in the parent's parent" do
-    lazy_eval(lambda { m2 }).must_equal 'PPm2'
+    _(lazy_eval(lambda { m2 })).must_equal 'PPm2'
   end
 
   it "invokes methods in the parent" do
-    lazy_eval(lambda { echo(m1) }).must_equal ['P', 'Pm1']
+    _(lazy_eval(lambda { echo(m1) })).must_equal ['P', 'Pm1']
   end
 
   it "invokes methods in the parent's parent" do
-    lazy_eval(lambda { parent.echo(m1) }, { m1: 'o1'}).must_equal ['PP', 'o1']
+    _(lazy_eval(lambda { parent.echo(m1) }, { m1: 'o1'})).must_equal ['PP', 'o1']
   end
 
   it "invokes methods in the parent's parent" do
-    lazy_eval(lambda { echo2(m1) }).must_equal ['PP2', 'Pm1']
+    _(lazy_eval(lambda { echo2(m1) })).must_equal ['PP2', 'Pm1']
   end
 
   it "resolves parameters in preference to methods in the parent" do
-    lazy_eval(lambda { com1 }).must_equal 'PpC'
+    _(lazy_eval(lambda { com1 })).must_equal 'PpC'
   end
 
   it "resolves methods in the parent explicitly" do
-    lazy_eval(lambda { parent.m1 }).must_equal 'PPm1'
+    _(lazy_eval(lambda { parent.m1 })).must_equal 'PPm1'
   end
 
   it "cascades lambdas " do
-    lazy_eval(lambda { sym1 }).must_equal 'PPm2'
-    lazy_eval(lambda { sym2 }).must_equal 'PPm2'
+    _(lazy_eval(lambda { sym1 })).must_equal 'PPm2'
+    _(lazy_eval(lambda { sym2 })).must_equal 'PPm2'
   end
 
   it "does not resolve #index" do
-    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
+    _ { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end

data/test/offset_test.rb

@@ -45,32 +45,32 @@ describe BinData::Base, "offsets" do
     it "fails when offset is incorrect" do
       io.seek(2)
       obj = TenByteOffsetBase.create(check_offset: 10 - 4)
-      lambda { obj.read(io) }.must_raise BinData::ValidityError
+      _ { obj.read(io) }.must_raise BinData::ValidityError
     end
 
     it "succeeds when offset is correct" do
       io.seek(3)
       obj = TenByteOffsetBase.create(check_offset: 10)
-      obj.read(io).snapshot.must_equal data[3 + 10, 3]
+      _(obj.read(io).snapshot).must_equal data[3 + 10, 3]
     end
 
     it "fails when :check_offset fails" do
       io.seek(4)
       obj = TenByteOffsetBase.create(check_offset: -> { offset == 10 + 1 } )
-      lambda { obj.read(io) }.must_raise BinData::ValidityError
+      _ { obj.read(io) }.must_raise BinData::ValidityError
     end
 
     it "succeeds when :check_offset succeeds" do
       io.seek(5)
       obj = TenByteOffsetBase.create(check_offset: -> { offset == 10 } )
-      obj.read(io).snapshot.must_equal data[5 + 10, 3]
+      _(obj.read(io).snapshot).must_equal data[5 + 10, 3]
     end
   end
 
   describe "with :adjust_offset" do
     it "is mutually exclusive with :check_offset" do
       params = { check_offset: 8, adjust_offset: 8 }
-      lambda { TenByteOffsetBase.create(params) }.must_raise ArgumentError
+      _ { TenByteOffsetBase.create(params) }.must_raise ArgumentError
     end
 
     it "adjust offset when incorrect" do
@@ -79,7 +79,7 @@ describe BinData::Base, "offsets" do
       begin
         io.seek(2)
         obj = TenByteOffsetBase.create(adjust_offset: 13)
-        obj.read(io).snapshot.must_equal data[2 + 13, 3]
+        _(obj.read(io).snapshot).must_equal data[2 + 13, 3]
       ensure
         $-w = w
       end
@@ -88,13 +88,13 @@ describe BinData::Base, "offsets" do
     it "succeeds when offset is correct" do
       io.seek(3)
       obj = TenByteOffsetBase.create(adjust_offset: 10)
-      obj.read(io).snapshot.must_equal data[3 + 10, 3]
+      _(obj.read(io).snapshot).must_equal data[3 + 10, 3]
     end
 
     it "fails if cannot adjust offset" do
       io.seek(4)
       obj = TenByteOffsetBase.create(adjust_offset: -5)
-      lambda { obj.read(io) }.must_raise BinData::ValidityError
+      _ { obj.read(io) }.must_raise BinData::ValidityError
     end
   end
 end

data/test/params_test.rb

@@ -5,15 +5,15 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 
 describe BinData::Base, "parameters" do
   it "fails when parameter name is invalid" do
-    lambda {
+    _ {
       class InvalidParameterNameBase < BinData::Base
-        optional_parameter :eval # i.e. Kernel#eval
+        optional_parameter :lazy_eval # from LazyEvaluator
       end
     }.must_raise NameError
   end
 
   it "fails when parameter has nil value" do
-    lambda { BinData::Base.new(a: nil) }.must_raise ArgumentError
+    _ { BinData::Base.new(a: nil) }.must_raise ArgumentError
   end
 end
 
@@ -32,17 +32,17 @@ end
 describe BinData::Base, "#get_parameter" do
   it "retrieves parameter values" do
     obj = BinData::Base.new(a: 3)
-    obj.get_parameter(:a).must_equal 3
+    _(obj.get_parameter(:a)).must_equal 3
   end
 
   it "retrieves parameter values with string keys" do
     obj = BinData::Base.new('a' => 3)
-    obj.get_parameter(:a).must_equal 3
+    _(obj.get_parameter(:a)).must_equal 3
   end
 
   it "returns nil for non existing parameters" do
     obj = BinData::Base.new
-    obj.get_parameter(:a).must_be_nil
+    _(obj.get_parameter(:a)).must_be_nil
   end
 
   it "wont eval parameters" do
@@ -54,12 +54,12 @@ end
 describe BinData::Base, "#eval_parameter" do
   it "evals the parameter" do
     obj = BinData::Base.new(a: -> { 3 })
-    obj.eval_parameter(:a).must_equal 3
+    _(obj.eval_parameter(:a)).must_equal 3
   end
 
   it "returns nil for a non existing parameter" do
     obj = BinData::Base.new
-    obj.eval_parameter(:a).must_be_nil
+    _(obj.eval_parameter(:a)).must_be_nil
   end
 end
 
@@ -71,11 +71,11 @@ describe BinData::Base, ".mandatory_parameters" do
 
   it "fails when not all mandatory parameters are present" do
     params = {p1: "a", xx: "b" }
-    lambda { MandatoryBase.new(params) }.must_raise ArgumentError
+    _ { MandatoryBase.new(params) }.must_raise ArgumentError
   end
 
   it "fails when no mandatory parameters are present" do
-    lambda { MandatoryBase.new() }.must_raise ArgumentError
+    _ { MandatoryBase.new() }.must_raise ArgumentError
   end
 end
 
@@ -86,12 +86,12 @@ describe BinData::Base, ".default_parameters" do
 
   it "uses default parameters when not specified" do
     obj = DefaultBase.new
-    obj.eval_parameter(:p1).must_equal "a"
+    _(obj.eval_parameter(:p1)).must_equal "a"
   end
 
   it "can override default parameters" do
     obj = DefaultBase.new(p1: "b")
-    obj.eval_parameter(:p1).must_equal "b"
+    _(obj.eval_parameter(:p1)).must_equal "b"
   end
 end
 
@@ -102,9 +102,9 @@ describe BinData::Base, ".mutually_exclusive_parameters" do
   end
 
   it "fails when any two of those parameters are present" do
-    lambda { MutexParamBase.new(p1: "a", p2: "b") }.must_raise ArgumentError
-    lambda { MutexParamBase.new(p1: "a", p3: "c") }.must_raise ArgumentError
-    lambda { MutexParamBase.new(p2: "b", p3: "c") }.must_raise ArgumentError
+    _ { MutexParamBase.new(p1: "a", p2: "b") }.must_raise ArgumentError
+    _ { MutexParamBase.new(p1: "a", p3: "c") }.must_raise ArgumentError
+    _ { MutexParamBase.new(p2: "b", p3: "c") }.must_raise ArgumentError
   end
 end
 
@@ -119,8 +119,8 @@ describe BinData::Base, "subclassing" do
 
   it "inherits parameters" do
     accepted = ParamLevel2Base.accepted_parameters.all
-    accepted.must_include :p1
-    accepted.must_include :p2
+    _(accepted).must_include :p1
+    _(accepted).must_include :p2
   end
 end
 
@@ -138,7 +138,7 @@ describe BinData::Base, "subclassing when skipping a level" do
 
   it "inherits parameters" do
     accepted = ParamLevel3Base.accepted_parameters.all
-    accepted.must_include :p1
-    accepted.must_include :p2
+    _(accepted).must_include :p1
+    _(accepted).must_include :p2
   end
 end

data/test/primitive_test.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 
 describe BinData::Primitive do
   it "is not registered" do
-    lambda {
+    _ {
       BinData::RegisteredClasses.lookup("Primitive")
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -18,14 +18,14 @@ describe BinData::Primitive, "all subclasses" do
   let(:obj) { SubClassOfPrimitive.new }
 
   it "raise errors on unimplemented methods" do
-    lambda { obj.set(nil) }.must_raise NotImplementedError
-    lambda { obj.get      }.must_raise NotImplementedError
+    _ { obj.set(nil) }.must_raise NotImplementedError
+    _ { obj.get      }.must_raise NotImplementedError
   end
 end
 
 describe BinData::Primitive, "when defining with errors" do
   it "fails on non registered types" do
-    lambda {
+    _ {
       class BadTypePrimitive < BinData::Primitive
         non_registered_type :a
       end
@@ -33,7 +33,7 @@ describe BinData::Primitive, "when defining with errors" do
   end
 
   it "fails on duplicate names" do
-    lambda {
+    _ {
       class DuplicateNamePrimitive < BinData::Primitive
         int8 :a
         int8 :b
@@ -43,15 +43,15 @@ describe BinData::Primitive, "when defining with errors" do
   end
 
   it "fails when field name shadows an existing method" do
-    lambda {
+    _ {
       class ExistingNamePrimitive < BinData::Primitive
         int8 :object_id
       end
-    }.must_raise_on_line NameError, 2, "field 'object_id' shadows an existing method in ExistingNamePrimitive"
+    }.must_raise_on_line SyntaxError, 2, "field 'object_id' shadows an existing method in ExistingNamePrimitive"
   end
 
   it "fails on unknown endian" do
-    lambda {
+    _ {
       class BadEndianPrimitive < BinData::Primitive
         endian 'a bad value'
       end
@@ -71,30 +71,30 @@ describe BinData::Primitive do
 
   it "assigns value" do
     obj.value = 5
-    obj.value.must_equal 5
+    _(obj.value).must_equal 5
   end
 
   it "produces binary string" do
     obj.assign(5)
-    obj.to_binary_s.must_equal_binary "\x05\x00"
+    _(obj.to_binary_s).must_equal_binary "\x05\x00"
   end
 
   it "reads value" do
     obj.read("\x00\x01")
-    obj.must_equal 0x100
+    _(obj).must_equal 0x100
   end
 
   it "accepts standard parameters" do
     obj = PrimitiveWithEndian.new(initial_value: 2)
-    obj.to_binary_s.must_equal_binary "\x02\x00"
+    _(obj.to_binary_s).must_equal_binary "\x02\x00"
   end
 
   it "returns num_bytes" do
-    obj.num_bytes.must_equal 2
+    _(obj.num_bytes).must_equal 2
   end
 
   it "raises error on missing methods" do
-    lambda {
+    _ {
       obj.does_not_exist
     }.must_raise NoMethodError
   end
@@ -102,16 +102,16 @@ describe BinData::Primitive do
   it "uses read value whilst reading" do
     obj = PrimitiveWithEndian.new(value: 2)
     obj.read "\x05\x00"
-    obj.must_equal 2
+    _(obj).must_equal 2
 
     obj.stub :reading?, true do
-      obj.must_equal 5
+      _(obj).must_equal 5
     end
   end
 
   it "behaves as primitive" do
     obj.assign(5)
-    (2 + obj).must_equal 7
+    _((2 + obj)).must_equal 7
   end
 end
 
@@ -124,7 +124,7 @@ describe BinData::Primitive, "requiring custom parameters" do
 
   it "passes parameters correctly" do
     obj = PrimitiveWithCustom.new(iv: 5)
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 end
 
@@ -138,12 +138,12 @@ describe BinData::Primitive, "with custom mandatory parameters" do
   end
 
   it "raises error if mandatory parameter is not supplied" do
-    lambda { MandatoryPrimitive.new }.must_raise ArgumentError
+    _ { MandatoryPrimitive.new }.must_raise ArgumentError
   end
 
   it "uses mandatory parameter" do
     obj = MandatoryPrimitive.new(arg1: 5)
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 end
 
@@ -158,12 +158,12 @@ describe BinData::Primitive, "with custom default parameters" do
 
   it "uses default parameter" do
     obj = DefaultPrimitive.new
-    obj.must_equal 5
+    _(obj).must_equal 5
   end
 
   it "overrides default parameter" do
     obj = DefaultPrimitive.new(arg1: 7)
-    obj.must_equal 7
+    _(obj).must_equal 7
   end
 end
 
@@ -180,12 +180,12 @@ describe BinData::Primitive, "subclassed with default parameter" do
 
   it "overrides initial_value" do
     a = ChildDerivedPrimitive.new(initial_value: 7)
-    a.to_binary_s.must_equal_binary "\000\007"
+    _(a.to_binary_s).must_equal_binary "\000\007"
   end
 
   it "uses default parameter" do
     a = ChildDerivedPrimitive.new
-    a.to_binary_s.must_equal_binary "\000\005"
+    _(a.to_binary_s).must_equal_binary "\000\005"
   end
 end
 
@@ -199,12 +199,12 @@ describe BinData::Primitive, "with mutating #get and #set" do
   it "#assign applies mutator" do
     obj = MutatingPrimitive.new
     obj.assign(-50)
-    obj.snapshot.must_equal 50
+    _(obj.snapshot).must_equal 50
   end
 
   it "#to_binary_s applies mutator" do
     obj = MutatingPrimitive.new
     obj.assign(-50)
-    obj.to_binary_s.must_equal_binary "\062\000"
+    _(obj.to_binary_s).must_equal_binary "\062\000"
   end
 end