bindata 2.4.13 → 2.4.14

data/test/registry_test.rb

@@ -14,14 +14,14 @@ describe BinData::Registry do
     r.register('ASubClass', A)
     r.register('AnotherSubClass', B)
 
-    r.lookup('ASubClass').must_equal A
-    r.lookup('a_sub_class').must_equal A
-    r.lookup('AnotherSubClass').must_equal B
-    r.lookup('another_sub_class').must_equal B
+    _(r.lookup('ASubClass')).must_equal A
+    _(r.lookup('a_sub_class')).must_equal A
+    _(r.lookup('AnotherSubClass')).must_equal B
+    _(r.lookup('another_sub_class')).must_equal B
   end
 
   it "does not lookup unregistered names" do
-    lambda {
+    _ {
       r.lookup('a_non_existent_sub_class')
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -30,7 +30,7 @@ describe BinData::Registry do
     r.register('ASubClass', A)
     r.unregister('ASubClass')
 
-    lambda {
+    _ {
       r.lookup('ASubClass')
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -42,22 +42,22 @@ describe BinData::Registry do
       r.register('A', A)
       r.register('A', B)
 
-      r.lookup('a').must_equal B
+      _(r.lookup('a')).must_equal B
     ensure
       $-w = w
     end
   end
 
   it "converts CamelCase to underscores" do
-    r.underscore_name('CamelCase').must_equal 'camel_case'
+    _(r.underscore_name('CamelCase')).must_equal 'camel_case'
   end
 
   it "converts adjacent caps camelCase to underscores" do
-    r.underscore_name('XYZCamelCase').must_equal 'xyz_camel_case'
+    _(r.underscore_name('XYZCamelCase')).must_equal 'xyz_camel_case'
   end
 
   it "ignores the outer nestings of classes" do
-    r.underscore_name('A::B::C').must_equal 'c'
+    _(r.underscore_name('A::B::C')).must_equal 'c'
   end
 end
 
@@ -65,14 +65,14 @@ describe BinData::Registry, "with numerics" do
   let(:r) { BinData::RegisteredClasses }
 
   it "lookup integers with endian" do
-    r.lookup("int24", {endian: :big}).to_s.must_equal "BinData::Int24be"
-    r.lookup("int24", {endian: :little}).to_s.must_equal "BinData::Int24le"
-    r.lookup("uint24", {endian: :big}).to_s.must_equal "BinData::Uint24be"
-    r.lookup("uint24", {endian: :little}).to_s.must_equal "BinData::Uint24le"
+    _(r.lookup("int24", {endian: :big}).to_s).must_equal "BinData::Int24be"
+    _(r.lookup("int24", {endian: :little}).to_s).must_equal "BinData::Int24le"
+    _(r.lookup("uint24", {endian: :big}).to_s).must_equal "BinData::Uint24be"
+    _(r.lookup("uint24", {endian: :little}).to_s).must_equal "BinData::Uint24le"
   end
 
   it "does not lookup integers without endian" do
-    lambda {
+    _ {
       r.lookup("int24")
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -81,47 +81,47 @@ describe BinData::Registry, "with numerics" do
     begin
       r.lookup("int24")
     rescue BinData::UnRegisteredTypeError => e
-      e.message.must_equal "int24, do you need to specify endian?"
+      _(e.message).must_equal "int24, do you need to specify endian?"
     end
   end
 
   it "does not lookup non byte based integers" do
-    lambda {
+    _ {
       r.lookup("int3")
     }.must_raise BinData::UnRegisteredTypeError
-    lambda {
+    _ {
       r.lookup("int3", {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
-    lambda {
+    _ {
       r.lookup("int3", {endian: :little})
     }.must_raise BinData::UnRegisteredTypeError
   end
 
   it "lookup floats with endian" do
-    r.lookup("float", {endian: :big}).to_s.must_equal "BinData::FloatBe"
-    r.lookup("float", {endian: :little}).to_s.must_equal "BinData::FloatLe"
-    r.lookup("double", {endian: :big}).to_s.must_equal "BinData::DoubleBe"
-    r.lookup("double", {endian: :little}).to_s.must_equal "BinData::DoubleLe"
+    _(r.lookup("float", {endian: :big}).to_s).must_equal "BinData::FloatBe"
+    _(r.lookup("float", {endian: :little}).to_s).must_equal "BinData::FloatLe"
+    _(r.lookup("double", {endian: :big}).to_s).must_equal "BinData::DoubleBe"
+    _(r.lookup("double", {endian: :little}).to_s).must_equal "BinData::DoubleLe"
   end
 
   it "lookup bits" do
-    r.lookup("bit5").to_s.must_equal "BinData::Bit5"
-    r.lookup("sbit5").to_s.must_equal "BinData::Sbit5"
-    r.lookup("bit6le").to_s.must_equal "BinData::Bit6le"
+    _(r.lookup("bit5").to_s).must_equal "BinData::Bit5"
+    _(r.lookup("sbit5").to_s).must_equal "BinData::Sbit5"
+    _(r.lookup("bit6le").to_s).must_equal "BinData::Bit6le"
   end
 
   it "lookup bits by ignoring endian" do
-    r.lookup("bit2", {endian: :big}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {endian: :big}).to_s.must_equal "BinData::Bit3le"
-    r.lookup("bit2", {endian: :little}).to_s.must_equal "BinData::Bit2"
-    r.lookup("bit3le", {endian: :little}).to_s.must_equal "BinData::Bit3le"
+    _(r.lookup("bit2", {endian: :big}).to_s).must_equal "BinData::Bit2"
+    _(r.lookup("bit3le", {endian: :big}).to_s).must_equal "BinData::Bit3le"
+    _(r.lookup("bit2", {endian: :little}).to_s).must_equal "BinData::Bit2"
+    _(r.lookup("bit3le", {endian: :little}).to_s).must_equal "BinData::Bit3le"
   end
 
   it "lookup signed bits by ignoring endian" do
-    r.lookup("sbit2", {endian: :big}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {endian: :big}).to_s.must_equal "BinData::Sbit3le"
-    r.lookup("sbit2", {endian: :little}).to_s.must_equal "BinData::Sbit2"
-    r.lookup("sbit3le", {endian: :little}).to_s.must_equal "BinData::Sbit3le"
+    _(r.lookup("sbit2", {endian: :big}).to_s).must_equal "BinData::Sbit2"
+    _(r.lookup("sbit3le", {endian: :big}).to_s).must_equal "BinData::Sbit3le"
+    _(r.lookup("sbit2", {endian: :little}).to_s).must_equal "BinData::Sbit2"
+    _(r.lookup("sbit3le", {endian: :little}).to_s).must_equal "BinData::Sbit3le"
   end
 end
 
@@ -134,15 +134,15 @@ describe BinData::Registry, "with endian specific types" do
   end
   
   it "lookup little endian types" do
-    r.lookup('a', {endian: :little}).must_equal A
+    _(r.lookup('a', {endian: :little})).must_equal A
   end
 
   it "lookup big endian types" do
-    r.lookup('b', {endian: :big}).must_equal B
+    _(r.lookup('b', {endian: :big})).must_equal B
   end
 
   it "does not lookup types with non existent endian" do
-    lambda {
+    _ {
       r.lookup('a', {endian: :big})
     }.must_raise BinData::UnRegisteredTypeError
   end
@@ -151,7 +151,7 @@ describe BinData::Registry, "with endian specific types" do
     r.register('c', C)
     r.register('c_le', D)
 
-    r.lookup('c', {endian: :little}).must_equal C
+    _(r.lookup('c', {endian: :little})).must_equal C
   end
 end
 
@@ -164,18 +164,18 @@ describe BinData::Registry, "with search_prefix" do
   end
 
   it "lookup single search_prefix" do
-    r.lookup('f', {search_prefix: :a}).must_equal A
+    _(r.lookup('f', {search_prefix: :a})).must_equal A
   end
 
   it "lookup single search_prefix with endian" do
-    r.lookup('f', {search_prefix: :a, endian: :little}).must_equal A
+    _(r.lookup('f', {search_prefix: :a, endian: :little})).must_equal A
   end
 
   it "lookup multiple search_prefix" do
-    r.lookup('f', {search_prefix: [:x, :a]}).must_equal A
+    _(r.lookup('f', {search_prefix: [:x, :a]})).must_equal A
   end
 
   it "lookup first match in search_prefix" do
-    r.lookup('f', {search_prefix: [:a, :b]}).must_equal A
+    _(r.lookup('f', {search_prefix: [:a, :b]})).must_equal A
   end
 end

data/test/rest_test.rb

@@ -6,23 +6,23 @@ describe BinData::Rest do
   let(:obj) { BinData::Rest.new }
 
   it "initial state" do
-    obj.must_equal ""
+    _(obj).must_equal ""
   end
 
   it "reads till end of stream" do
     data = "abcdefghij"
-    obj.read(data).must_equal data
+    _(obj.read(data)).must_equal data
   end
 
   it "allows setting value for completeness" do
     obj.assign("123")
-    obj.must_equal "123"
-    obj.to_binary_s.must_equal_binary "123"
+    _(obj).must_equal "123"
+    _(obj.to_binary_s).must_equal_binary "123"
   end
 
   it "accepts BinData::BasePrimitive parameters" do
     rest = BinData::Rest.new(assert: "abc")
-    lambda {
+    _ {
       rest.read("xyz")
     }.must_raise BinData::ValidityError
   end

data/test/skip_test.rb

@@ -6,7 +6,7 @@ describe BinData::Skip, "when instantiating" do
   describe "with no mandatory parameters supplied" do
     it "raises an error" do
       args = {}
-      lambda { BinData::Skip.new(args) }.must_raise ArgumentError
+      _ { BinData::Skip.new(args) }.must_raise ArgumentError
     end
   end
 end
@@ -16,23 +16,23 @@ describe BinData::Skip, "with :length" do
   let(:io) { StringIO.new("abcdefghij") }
 
   it "initial state" do
-    obj.must_equal ""
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj).must_equal ""
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 
   it "skips bytes" do
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "has expected binary representation after setting value" do
     obj.assign("123")
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 
   it "has expected binary representation after reading" do
     obj.read(io)
-    obj.to_binary_s.must_equal_binary "\000" * 5
+    _(obj.to_binary_s).must_equal_binary "\000" * 5
   end
 end
 
@@ -46,21 +46,21 @@ describe BinData::Skip, "with :to_abs_offset" do
     fields = [ skip_obj ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "reads skipping in place" do
     fields = [ [:string, :a, { read_length: 5 }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "does not read skipping backwards" do
     fields = [ [:string, :a, { read_length: 10 }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
 
-    lambda {
+    _ {
       obj.read(io)
     }.must_raise BinData::ValidityError
   end
@@ -68,19 +68,19 @@ describe BinData::Skip, "with :to_abs_offset" do
   it "writes skipping forward" do
     fields = [ skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    obj.to_binary_s.must_equal "\000\000\000\000\000"
+    _(obj.to_binary_s).must_equal "\000\000\000\000\000"
   end
 
   it "reads skipping in place" do
     fields = [ [:string, :a, { value: "abcde" }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    obj.to_binary_s.must_equal "abcde"
+    _(obj.to_binary_s).must_equal "abcde"
   end
 
   it "does not write skipping backwards" do
     fields = [ [:string, :a, { value: "abcdefghij" }], skip_obj ]
     obj = BinData::Struct.new(fields: fields)
-    lambda {
+    _ {
       obj.to_binary_s
     }.must_raise BinData::ValidityError
   end
@@ -94,7 +94,7 @@ describe BinData::Skip, "with :until_valid" do
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   it "doesn't skip when validator doesn't assert" do
@@ -102,14 +102,14 @@ describe BinData::Skip, "with :until_valid" do
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
     obj.read(io)
-    io.pos.must_equal 0
+    _(io.pos).must_equal 0
   end
 
   it "raises EOFError when no match" do
     skip_obj = [:string, { read_length: 1, assert: "X" }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
-    lambda {
+    _ {
       obj.read(io)
     }.must_raise EOFError
   end
@@ -118,7 +118,7 @@ describe BinData::Skip, "with :until_valid" do
     skip_obj = [:string, { read_length: 30 }]
     fields = [ [:skip, :s, { until_valid: skip_obj }] ]
     obj = BinData::Struct.new(fields: fields)
-    lambda {
+    _ {
       obj.read(io)
     }.must_raise IOError
   end
@@ -132,6 +132,6 @@ describe BinData::Skip, "with :until_valid" do
 
   it "uses block form" do
     obj = DSLSkip.read(io)
-    obj.a.must_equal "f"
+    _(obj.a).must_equal "f"
   end
 end

data/test/string_test.rb

@@ -5,17 +5,17 @@ require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
 describe BinData::String, "with mutually exclusive parameters" do
   it ":value and :initial_value" do
     params = {value: "", initial_value: ""}
-    lambda { BinData::String.new(params) }.must_raise ArgumentError
+    _ { BinData::String.new(params) }.must_raise ArgumentError
   end
 
   it ":length and :read_length" do
     params = {length: 5, read_length: 5}
-    lambda { BinData::String.new(params) }.must_raise ArgumentError
+    _ { BinData::String.new(params) }.must_raise ArgumentError
   end
 
   it ":value and :length" do
     params = {value: "", length: 5}
-    lambda { BinData::String.new(params) }.must_raise ArgumentError
+    _ { BinData::String.new(params) }.must_raise ArgumentError
   end
 end
 
@@ -25,12 +25,12 @@ describe BinData::String, "when assigning" do
 
   it "copies data from small to large" do
     large.assign(small)
-    large.must_equal "AAABB"
+    _(large).must_equal "AAABB"
   end
 
   it "copies data from large to small" do
     small.assign(large)
-    small.must_equal "BBB"
+    _(small).must_equal "BBB"
   end
 end
 
@@ -38,96 +38,96 @@ describe BinData::String do
   let(:obj) { BinData::String.new("testing") }
 
   it "compares with regexp" do
-    (/es/ =~ obj).must_equal 1
+    _((/es/ =~ obj)).must_equal 1
   end
 
   it "compares with regexp" do
-    (obj =~ /es/).must_equal 1
+    _((obj =~ /es/)).must_equal 1
   end
 end
 
 describe BinData::String, "with :read_length" do
   let(:obj) { BinData::String.new(read_length: 5) }
 
-  specify { obj.num_bytes.must_equal 0 }
-  specify { obj.value.must_equal "" }
+  specify { _(obj.num_bytes).must_equal 0 }
+  specify { _(obj.value).must_equal "" }
 
   it "reads :read_length bytes" do
     obj.read("abcdefghij")
-    obj.must_equal "abcde"
+    _(obj).must_equal "abcde"
   end
 
   it "remembers :read_length after value is cleared" do
     obj.assign("abc")
-    obj.num_bytes.must_equal 3
+    _(obj.num_bytes).must_equal 3
     obj.clear
 
     obj.read("abcdefghij")
-    obj.must_equal "abcde"
+    _(obj).must_equal "abcde"
   end
 end
 
 describe BinData::String, "with :length" do
   let(:obj) { BinData::String.new(length: 5) }
 
-  specify { obj.num_bytes.must_equal 5 }
-  specify { obj.value.must_equal "\0\0\0\0\0" }
+  specify { _(obj.num_bytes).must_equal 5 }
+  specify { _(obj.value).must_equal "\0\0\0\0\0" }
 
   it "retains :length after value is set" do
     obj.assign("abcdefghij")
-    obj.num_bytes.must_equal 5
+    _(obj.num_bytes).must_equal 5
   end
 
   it "reads :length bytes" do
     obj.read("abcdefghij")
-    obj.must_equal "abcde"
+    _(obj).must_equal "abcde"
   end
 
   it "pads values less than :length" do
     obj.assign("abc")
-    obj.must_equal "abc\0\0"
+    _(obj).must_equal "abc\0\0"
   end
 
   it "accepts values exactly :length" do
     obj.assign("abcde")
-    obj.must_equal "abcde"
+    _(obj).must_equal "abcde"
   end
 
   it "truncates values greater than :length" do
     obj.assign("abcdefghij")
-    obj.must_equal "abcde"
+    _(obj).must_equal "abcde"
   end
 end
 
 describe BinData::String, "with :read_length and :initial_value" do
   let(:obj) { BinData::String.new(read_length: 5, initial_value: "abcdefghij") }
 
-  specify { obj.num_bytes.must_equal 10 }
-  specify { obj.value.must_equal "abcdefghij" }
+  specify { _(obj.num_bytes).must_equal 10 }
+  specify { _(obj.value).must_equal "abcdefghij" }
 
   it "uses :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
    end
 
   it "forgets :initial_value after reading" do
     obj.read("ABCDEFGHIJKLMNOPQRST")
-    obj.num_bytes.must_equal 5
-    obj.must_equal "ABCDE"
+    _(obj.num_bytes).must_equal 5
+    _(obj).must_equal "ABCDE"
   end
 end
 
 describe BinData::String, "with :read_length and :value" do
   let(:obj) { BinData::String.new(read_length: 5, value: "abcdefghij") }
 
-  specify { obj.num_bytes.must_equal 10 }
-  specify { obj.value.must_equal "abcdefghij" }
+  specify { _(obj.num_bytes).must_equal 10 }
+  specify { _(obj.value).must_equal "abcdefghij" }
 
   it "uses :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     obj.read(io)
-    io.pos.must_equal 5
+    _(io.pos).must_equal 5
   end
 
   describe "after reading" do
@@ -136,13 +136,13 @@ describe BinData::String, "with :read_length and :value" do
     end
 
     it "is not affected by :read_length after reading" do
-      obj.num_bytes.must_equal 10
-      obj.must_equal "abcdefghij"
+      _(obj.num_bytes).must_equal 10
+      _(obj).must_equal "abcdefghij"
     end
 
     it "returns read value while reading" do
       obj.stub :reading?, true do
-        obj.must_equal "ABCDE"
+        _(obj).must_equal "ABCDE"
       end
     end
   end
@@ -151,15 +151,15 @@ end
 describe BinData::String, "with :length and :initial_value" do
   let(:obj) { BinData::String.new(length: 5, initial_value: "abcdefghij") }
 
-  specify { obj.num_bytes.must_equal 5 }
-  specify { obj.value.must_equal "abcde" }
+  specify { _(obj.num_bytes).must_equal 5 }
+  specify { _(obj.value).must_equal "abcde" }
 
   it "forgets :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     obj.read(io)
-    io.pos.must_equal 5
-    obj.num_bytes.must_equal 5
-    obj.must_equal "ABCDE"
+    _(io.pos).must_equal 5
+    _(obj.num_bytes).must_equal 5
+    _(obj).must_equal "ABCDE"
   end
 end
 
@@ -167,18 +167,18 @@ describe BinData::String, "with :pad_byte" do
   it "accepts a numeric value for :pad_byte" do
     str = BinData::String.new(length: 5, pad_byte: 6)
     str.assign("abc")
-    str.must_equal "abc\x06\x06"
+    _(str).must_equal "abc\x06\x06"
   end
 
   it "accepts a character for :pad_byte" do
     str = BinData::String.new(length: 5, pad_byte: "R")
     str.assign("abc")
-    str.must_equal "abcRR"
+    _(str).must_equal "abcRR"
   end
 
   it "does not accept a string for :pad_byte" do
     params = {length: 5, pad_byte: "RR"}
-    lambda { BinData::String.new(params) }.must_raise ArgumentError
+    _ { BinData::String.new(params) }.must_raise ArgumentError
   end
 end
 
@@ -188,8 +188,8 @@ describe BinData::String, "with :trim_padding" do
     str2 = BinData::String.new(length: 5, trim_padding: false)
     str1.assign("abc")
     str2.assign("abc")
-    str1.must_equal "abc\0\0"
-    str2.must_equal "abc\0\0"
+    _(str1).must_equal "abc\0\0"
+    _(str2).must_equal "abc\0\0"
   end
 
   describe "trim padding set" do
@@ -197,22 +197,22 @@ describe BinData::String, "with :trim_padding" do
 
     it "trims the value" do
       obj.assign("abcRR")
-      obj.must_equal "abc"
+      _(obj).must_equal "abc"
     end
 
     it "does not affect num_bytes" do
       obj.assign("abcRR")
-      obj.num_bytes.must_equal 5
+      _(obj.num_bytes).must_equal 5
     end
 
     it "trims if last char is :pad_byte" do
       obj.assign("abcRR")
-      obj.must_equal "abc"
+      _(obj).must_equal "abc"
     end
 
     it "does not trim if value contains :pad_byte not at the end" do
       obj.assign("abcRRde")
-      obj.must_equal "abcRRde"
+      _(obj).must_equal "abcRRde"
     end
   end
 end
@@ -223,20 +223,20 @@ describe BinData::String, "with :pad_front" do
     str2 = BinData::String.new(length: 5, pad_front: false)
     str1.assign("abc")
     str2.assign("abc")
-    str1.must_equal "abc\0\0"
-    str2.must_equal "abc\0\0"
+    _(str1).must_equal "abc\0\0"
+    _(str2).must_equal "abc\0\0"
   end
 
   it "pads to the front" do
     str = BinData::String.new(length: 5, pad_byte: 'R', pad_front: true)
     str.assign("abc")
-    str.must_equal "RRabc"
+    _(str).must_equal "RRabc"
   end
 
   it "can alternatively be accesses by :pad_left" do
     str = BinData::String.new(length: 5, pad_byte: 'R', pad_left: true)
     str.assign("abc")
-    str.must_equal "RRabc"
+    _(str).must_equal "RRabc"
   end
 
   describe "and :trim_padding" do
@@ -244,17 +244,17 @@ describe BinData::String, "with :pad_front" do
 
     it "assigns" do
       obj.assign("abc")
-      obj.must_equal "abc"
+      _(obj).must_equal "abc"
     end
 
     it "has to_binary_s" do
       obj.assign("abc")
-      obj.to_binary_s.must_equal_binary "RRabc"
+      _(obj.to_binary_s).must_equal_binary "RRabc"
     end
 
     it "reads" do
       obj.read "RRabc"
-      obj.must_equal "abc"
+      _(obj).must_equal "abc"
     end
   end
 end
@@ -272,26 +272,26 @@ describe BinData::String, "with Ruby 1.9 encodings" do
 
   it "stores assigned values as binary" do
     obj.assign(utf8_str)
-    obj.to_binary_s.must_equal_binary binary_str
+    _(obj.to_binary_s).must_equal_binary binary_str
   end
 
   it "stores read values as binary" do
     obj = UTF8String.new(read_length: binary_str.bytesize)
     obj.read(binary_str)
 
-    obj.to_binary_s.must_equal_binary binary_str
+    _(obj.to_binary_s).must_equal_binary binary_str
   end
 
   it "returns values in correct encoding" do
     obj.assign(utf8_str)
 
-    obj.snapshot.must_equal utf8_str
+    _(obj.snapshot).must_equal utf8_str
   end
 
   it "has correct num_bytes" do
     obj.assign(utf8_str)
 
-    obj.num_bytes.must_equal binary_str.bytesize
+    _(obj.num_bytes).must_equal binary_str.bytesize
   end
 end
 
@@ -299,7 +299,7 @@ describe BinData::String, "warnings" do
   it "warns if has :asserted_value but no :length" do
     obj = BinData::String.new(asserted_value: "ABC")
     obj.must_warn "obj does not have a :read_length parameter - returning empty string" do
-      lambda { obj.read("abcde") }.must_raise BinData::ValidityError
+      _ { obj.read("abcde") }.must_raise BinData::ValidityError
     end
   end