bindata 2.4.13 → 2.4.14

data/test/int_test.rb

@@ -6,13 +6,13 @@ module AllIntegers
 
   def test_have_correct_num_bytes
     all_classes do |int_class|
-      int_class.new.num_bytes.must_equal @nbytes
+      _(int_class.new.num_bytes).must_equal @nbytes
     end
   end
 
   def test_have_a_sensible_value_of_zero
     all_classes do |int_class|
-      int_class.new.must_equal 0
+      _(int_class.new).must_equal 0
     end
   end
 
@@ -21,7 +21,7 @@ module AllIntegers
       subject = int_class.new
       subject.assign(min_value - 1)
 
-      subject.must_equal min_value
+      _(subject).must_equal min_value
     end
   end
 
@@ -30,7 +30,7 @@ module AllIntegers
       subject = int_class.new
       subject.assign(max_value + 1)
 
-      subject.must_equal max_value
+      _(subject).must_equal max_value
     end
   end
 
@@ -40,7 +40,7 @@ module AllIntegers
       test_int = gen_test_int
       subject.assign(test_int)
 
-      subject.must_equal test_int
+      _(subject).must_equal test_int
     end
   end
 
@@ -51,7 +51,7 @@ module AllIntegers
 
       subject = int_class.new
       subject.assign(src)
-      subject.must_equal src
+      _(subject).must_equal src
     end
   end
 
@@ -60,7 +60,7 @@ module AllIntegers
       subject = int_class.new
       subject.assign(gen_test_int)
 
-      subject.value_read_from_written.must_equal subject
+      _(subject.value_read_from_written).must_equal subject
     end
   end
 
@@ -70,7 +70,7 @@ module AllIntegers
         subject = int_class.new
         subject.assign(-gen_test_int)
 
-        subject.value_read_from_written.must_equal subject
+        _(subject.value_read_from_written).must_equal subject
       end
     end
   end
@@ -82,7 +82,7 @@ module AllIntegers
       subject = int_class.new
       subject.assign(val)
 
-      subject.to_binary_s.must_equal_binary int_to_binary_str(val)
+      _(subject.to_binary_s).must_equal_binary int_to_binary_str(val)
     end
   end
 
@@ -94,7 +94,7 @@ module AllIntegers
         subject = int_class.new
         subject.assign(val)
 
-        subject.to_binary_s.must_equal_binary int_to_binary_str(val)
+        _(subject.to_binary_s).must_equal_binary int_to_binary_str(val)
       end
     end
   end
@@ -195,12 +195,12 @@ end
 
 describe "Custom defined integers" do
   it "fail unless bits are a multiple of 8" do
-    lambda { BinData::Uint7le }.must_raise NameError
+    _ { BinData::Uint7le }.must_raise NameError
 
-    lambda { BinData::Uint7be }.must_raise NameError
+    _ { BinData::Uint7be }.must_raise NameError
 
-    lambda { BinData::Int7le }.must_raise NameError
+    _ { BinData::Int7le }.must_raise NameError
 
-    lambda { BinData::Int7be }.must_raise NameError
+    _ { BinData::Int7be }.must_raise NameError
   end
 end

data/test/io_test.rb

@@ -17,16 +17,16 @@ describe BinData::IO::Read, "reading from non seekable stream" do
 
   it "has correct offset" do
     @io.readbytes(10)
-    @io.offset.must_equal 10
+    _(@io.offset).must_equal 10
   end
 
   it "seeks correctly" do
     @io.seekbytes(1999)
-    @io.readbytes(5).must_equal "abbbb"
+    _(@io.readbytes(5)).must_equal "abbbb"
   end
 
   it "#num_bytes_remaining raises IOError" do
-    lambda {
+    _ {
       @io.num_bytes_remaining
     }.must_raise IOError
   end
@@ -37,7 +37,7 @@ describe BinData::IO::Read, "when reading" do
   let(:io) { BinData::IO::Read.new(stream) }
 
   it "raises error when io is BinData::IO::Read" do
-    lambda {
+    _ {
       BinData::IO::Read.new(BinData::IO::Read.new(""))
     }.must_raise ArgumentError
   end
@@ -45,36 +45,36 @@ describe BinData::IO::Read, "when reading" do
   it "returns correct offset" do
     stream.seek(3, IO::SEEK_CUR)
 
-    io.offset.must_equal 0
-    io.readbytes(4).must_equal "defg"
-    io.offset.must_equal 4
+    _(io.offset).must_equal 0
+    _(io.readbytes(4)).must_equal "defg"
+    _(io.offset).must_equal 4
   end
 
   it "seeks correctly" do
     io.seekbytes(2)
-    io.readbytes(4).must_equal "cdef"
+    _(io.readbytes(4)).must_equal "cdef"
   end
 
   it "reads all bytes" do
-    io.read_all_bytes.must_equal "abcdefghij"
+    _(io.read_all_bytes).must_equal "abcdefghij"
   end
 
   it "returns number of bytes remaining" do
     stream_length = io.num_bytes_remaining
 
     io.readbytes(4)
-    io.num_bytes_remaining.must_equal stream_length - 4
+    _(io.num_bytes_remaining).must_equal stream_length - 4
   end
 
   it "raises error when reading at eof" do
     io.seekbytes(10)
-    lambda {
+    _ {
       io.readbytes(3)
     }.must_raise EOFError
   end
 
   it "raises error on short reads" do
-    lambda {
+    _ {
       io.readbytes(20)
     }.must_raise IOError
   end
@@ -86,21 +86,21 @@ describe BinData::IO::Read, "#with_buffer" do
 
   it "consumes entire buffer on short reads" do
     io.with_buffer(10) do
-      io.readbytes(4).must_equal "abcd"
+      _(io.readbytes(4)).must_equal "abcd"
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "consumes entire buffer on read_all_bytes" do
     io.with_buffer(10) do
-      io.read_all_bytes.must_equal "abcdefghij"
+      _(io.read_all_bytes).must_equal "abcdefghij"
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "restricts large reads" do
     io.with_buffer(10) do
-      lambda {
+      _ {
         io.readbytes(15)
       }.must_raise IOError
     end
@@ -108,98 +108,98 @@ describe BinData::IO::Read, "#with_buffer" do
 
   it "is nestable" do
     io.with_buffer(10) do
-      io.readbytes(2).must_equal "ab"
+      _(io.readbytes(2)).must_equal "ab"
       io.with_buffer(5) do
-        io.read_all_bytes.must_equal "cdefg"
+        _(io.read_all_bytes).must_equal "cdefg"
       end
-      io.offset.must_equal(2 + 5)
+      _(io.offset).must_equal(2 + 5)
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "restricts large nested buffers" do
     io.with_buffer(10) do
-      io.readbytes(2).must_equal "ab"
+      _(io.readbytes(2)).must_equal "ab"
       io.with_buffer(20) do
-        io.read_all_bytes.must_equal "cdefghij"
-        io.offset.must_equal(10)
+        _(io.read_all_bytes).must_equal "cdefghij"
+        _(io.offset).must_equal(10)
       end
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "restricts large seeks" do
     io.with_buffer(10) do
       io.seekbytes(15)
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "restricts large -ve seeks" do
     io.readbytes(2)
     io.with_buffer(10) do
       io.seekbytes(-1)
-      io.offset.must_equal(2)
+      _(io.offset).must_equal(2)
     end
   end
 
   it "greater than stream size consumes all bytes" do
     io.with_buffer(30) do
-      io.readbytes(4).must_equal "abcd"
+      _(io.readbytes(4)).must_equal "abcd"
     end
-    io.offset.must_equal(20)
+    _(io.offset).must_equal(20)
   end
 
   it "restricts #num_bytes_remaining" do
     io.with_buffer(10) do
       io.readbytes(2)
-      io.num_bytes_remaining.must_equal 8
+      _(io.num_bytes_remaining).must_equal 8
     end
   end
 
   it "greater than stream size doesn't restrict #num_bytes_remaining" do
     io.with_buffer(30) do
       io.readbytes(2)
-      io.num_bytes_remaining.must_equal 18
+      _(io.num_bytes_remaining).must_equal 18
     end
   end
 end
 
 module IOReadWithReadahead
   def test_rolls_back_short_reads
-    io.readbytes(2).must_equal "ab"
+    _(io.readbytes(2)).must_equal "ab"
     io.with_readahead do
-      io.readbytes(4).must_equal "cdef"
+      _(io.readbytes(4)).must_equal "cdef"
     end
-    io.offset.must_equal 2
+    _(io.offset).must_equal 2
   end
 
   def test_rolls_back_read_all_bytes
-    io.readbytes(3).must_equal "abc"
+    _(io.readbytes(3)).must_equal "abc"
     io.with_readahead do
-      io.read_all_bytes.must_equal "defghijklmnopqrst"
+      _(io.read_all_bytes).must_equal "defghijklmnopqrst"
     end
-    io.offset.must_equal 3
+    _(io.offset).must_equal 3
   end
 
   def test_inside_buffer_rolls_back_reads
     io.with_buffer(10) do
       io.with_readahead do
-        io.readbytes(4).must_equal "abcd"
+        _(io.readbytes(4)).must_equal "abcd"
       end
-      io.offset.must_equal 0
+      _(io.offset).must_equal 0
     end
-    io.offset.must_equal 10
+    _(io.offset).must_equal 10
   end
 
   def test_outside_buffer_rolls_back_reads
     io.with_readahead do
       io.with_buffer(10) do
-        io.readbytes(4).must_equal "abcd"
+        _(io.readbytes(4)).must_equal "abcd"
       end
-      io.offset.must_equal 10
+      _(io.offset).must_equal 10
     end
-    io.offset.must_equal 0
+    _(io.offset).must_equal 0
   end
 end
 
@@ -236,29 +236,29 @@ describe BinData::IO::Write, "writing to non seekable stream" do
 
   it "writes data" do
     @io.writebytes("1234567890")
-    @rd.read(10).must_equal "1234567890"
+    _(@rd.read(10)).must_equal "1234567890"
   end
 
   it "has correct offset" do
     @io.writebytes("1234567890")
-    @io.offset.must_equal 10
+    _(@io.offset).must_equal 10
   end
 
   it "does not seek backwards" do
     @io.writebytes("1234567890")
-    lambda {
+    _ {
       @io.seekbytes(-5)
     }.must_raise IOError
   end
 
   it "does not seek forwards" do
-    lambda {
+    _ {
       @io.seekbytes(5)
     }.must_raise IOError
   end
 
   it "#num_bytes_remaining raises IOError" do
-    lambda {
+    _ {
       @io.num_bytes_remaining
     }.must_raise IOError
   end
@@ -269,7 +269,7 @@ describe BinData::IO::Write, "when writing" do
   let(:io) { BinData::IO::Write.new(stream) }
 
   it "raises error when io is BinData::IO" do
-    lambda {
+    _ {
       BinData::IO::Write.new(BinData::IO::Write.new(""))
     }.must_raise ArgumentError
   end
@@ -277,29 +277,29 @@ describe BinData::IO::Write, "when writing" do
   it "writes correctly" do
     io.writebytes("abcd")
 
-    stream.value.must_equal "abcd"
+    _(stream.value).must_equal "abcd"
   end
 
   it "has #offset" do
-    io.offset.must_equal 0
+    _(io.offset).must_equal 0
 
     io.writebytes("abcd")
-    io.offset.must_equal 4
+    _(io.offset).must_equal 4
 
     io.writebytes("ABCD")
-    io.offset.must_equal 8
+    _(io.offset).must_equal 8
   end
 
   it "rounds up #offset when writing bits" do
     io.writebits(123, 9, :little)
-    io.offset.must_equal 2
+    _(io.offset).must_equal 2
   end
 
   it "flushes" do
     io.writebytes("abcd")
     io.flush
 
-    stream.value.must_equal "abcd"
+    _(stream.value).must_equal "abcd"
   end
 end
 
@@ -312,7 +312,7 @@ describe BinData::IO::Write, "#with_buffer" do
       io.writebytes "abcde"
     end
 
-    stream.value.must_equal "abcde\0\0\0\0\0"
+    _(stream.value).must_equal "abcde\0\0\0\0\0"
   end
 
   it "discards excess on large writes" do
@@ -320,7 +320,7 @@ describe BinData::IO::Write, "#with_buffer" do
       io.writebytes "abcdefghij"
     end
 
-    stream.value.must_equal "abcde"
+    _(stream.value).must_equal "abcde"
   end
 
   it "is nestable" do
@@ -331,21 +331,21 @@ describe BinData::IO::Write, "#with_buffer" do
       io.writebytes "de"
     end
 
-    stream.value.must_equal "abc\0\0de\0\0\0"
+    _(stream.value).must_equal "abc\0\0de\0\0\0"
   end
 
   it "restricts large seeks" do
     io.with_buffer(10) do
       io.seekbytes(15)
     end
-    io.offset.must_equal(10)
+    _(io.offset).must_equal(10)
   end
 
   it "restricts large -ve seeks" do
     io.writebytes("12")
     io.with_buffer(10) do
       io.seekbytes(-1)
-      io.offset.must_equal(2)
+      _(io.offset).must_equal(2)
     end
   end
 end
@@ -357,42 +357,42 @@ describe BinData::IO::Read, "reading bits in big endian" do
   let(:io) { BinData::IO::Read.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
-    io.readbits(3, :big).must_equal 0b111
+    _(io.readbits(3, :big)).must_equal 0b111
   end
 
   it "reads a bitfield more than 1 byte" do
-    io.readbits(10, :big).must_equal 0b1111_1010_11
+    _(io.readbits(10, :big)).must_equal 0b1111_1010_11
   end
 
   it "reads a bitfield more than 2 bytes" do
-    io.readbits(17, :big).must_equal 0b1111_1010_1100_1110_0
+    _(io.readbits(17, :big)).must_equal 0b1111_1010_1100_1110_0
   end
 
   it "reads two bitfields totalling less than 1 byte" do
-    io.readbits(5, :big).must_equal 0b1111_1
-    io.readbits(2, :big).must_equal 0b01
+    _(io.readbits(5, :big)).must_equal 0b1111_1
+    _(io.readbits(2, :big)).must_equal 0b01
   end
 
   it "reads two bitfields totalling more than 1 byte" do
-    io.readbits(6, :big).must_equal 0b1111_10
-    io.readbits(8, :big).must_equal 0b10_1100_11
+    _(io.readbits(6, :big)).must_equal 0b1111_10
+    _(io.readbits(8, :big)).must_equal 0b10_1100_11
   end
 
   it "reads two bitfields totalling more than 2 bytes" do
-    io.readbits(7, :big).must_equal 0b1111_101
-    io.readbits(12, :big).must_equal 0b0_1100_1110_011
+    _(io.readbits(7, :big)).must_equal 0b1111_101
+    _(io.readbits(12, :big)).must_equal 0b0_1100_1110_011
   end
 
   it "ignores unused bits when reading bytes" do
-    io.readbits(3, :big).must_equal 0b111
-    io.readbytes(1).must_equal [b2].pack("C")
-    io.readbits(2, :big).must_equal 0b01
+    _(io.readbits(3, :big)).must_equal 0b111
+    _(io.readbytes(1)).must_equal [b2].pack("C")
+    _(io.readbits(2, :big)).must_equal 0b01
   end
 
   it "resets read bits to realign stream to next byte" do
-    io.readbits(3, :big).must_equal 0b111
+    _(io.readbits(3, :big)).must_equal 0b111
     io.reset_read_bits
-    io.readbits(3, :big).must_equal 0b110
+    _(io.readbits(3, :big)).must_equal 0b110
   end
 end
 
@@ -403,42 +403,42 @@ describe BinData::IO::Read, "reading bits in little endian" do
   let(:io) { BinData::IO::Read.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
-    io.readbits(3, :little).must_equal 0b010
+    _(io.readbits(3, :little)).must_equal 0b010
   end
 
   it "reads a bitfield more than 1 byte" do
-    io.readbits(10, :little).must_equal 0b10_1111_1010
+    _(io.readbits(10, :little)).must_equal 0b10_1111_1010
   end
 
   it "reads a bitfield more than 2 bytes" do
-    io.readbits(17, :little).must_equal 0b0_1100_1110_1111_1010
+    _(io.readbits(17, :little)).must_equal 0b0_1100_1110_1111_1010
   end
 
   it "reads two bitfields totalling less than 1 byte" do
-    io.readbits(5, :little).must_equal 0b1_1010
-    io.readbits(2, :little).must_equal 0b11
+    _(io.readbits(5, :little)).must_equal 0b1_1010
+    _(io.readbits(2, :little)).must_equal 0b11
   end
 
   it "reads two bitfields totalling more than 1 byte" do
-    io.readbits(6, :little).must_equal 0b11_1010
-    io.readbits(8, :little).must_equal 0b00_1110_11
+    _(io.readbits(6, :little)).must_equal 0b11_1010
+    _(io.readbits(8, :little)).must_equal 0b00_1110_11
   end
 
   it "reads two bitfields totalling more than 2 bytes" do
-    io.readbits(7, :little).must_equal 0b111_1010
-    io.readbits(12, :little).must_equal 0b010_1100_1110_1
+    _(io.readbits(7, :little)).must_equal 0b111_1010
+    _(io.readbits(12, :little)).must_equal 0b010_1100_1110_1
   end
 
   it "ignores unused bits when reading bytes" do
-    io.readbits(3, :little).must_equal 0b010
-    io.readbytes(1).must_equal [b2].pack("C")
-    io.readbits(2, :little).must_equal 0b10
+    _(io.readbits(3, :little)).must_equal 0b010
+    _(io.readbytes(1)).must_equal [b2].pack("C")
+    _(io.readbits(2, :little)).must_equal 0b10
   end
 
   it "resets read bits to realign stream to next byte" do
-    io.readbits(3, :little).must_equal 0b010
+    _(io.readbits(3, :little)).must_equal 0b010
     io.reset_read_bits
-    io.readbits(3, :little).must_equal 0b110
+    _(io.readbits(3, :little)).must_equal 0b110
   end
 end
 
@@ -468,35 +468,35 @@ describe BinData::IO::Write, "writing bits in big endian" do
 
   it "writes a bitfield less than 1 byte" do
     io.writebits(0b010, 3, :big)
-    io.value.must_equal [0b0100_0000].pack("C")
+    _(io.value).must_equal [0b0100_0000].pack("C")
   end
 
   it "writes a bitfield more than 1 byte" do
     io.writebits(0b10_1001_1101, 10, :big)
-    io.value.must_equal [0b1010_0111, 0b0100_0000].pack("CC")
+    _(io.value).must_equal [0b1010_0111, 0b0100_0000].pack("CC")
   end
 
   it "writes a bitfield more than 2 bytes" do
     io.writebits(0b101_1000_0010_1001_1101, 19, :big)
-    io.value.must_equal [0b1011_0000, 0b0101_0011, 0b1010_0000].pack("CCC")
+    _(io.value).must_equal [0b1011_0000, 0b0101_0011, 0b1010_0000].pack("CCC")
   end
 
   it "writes two bitfields totalling less than 1 byte" do
     io.writebits(0b1_1001, 5, :big)
     io.writebits(0b00, 2, :big)
-    io.value.must_equal [0b1100_1000].pack("C")
+    _(io.value).must_equal [0b1100_1000].pack("C")
   end
 
   it "writes two bitfields totalling more than 1 byte" do
     io.writebits(0b01_0101, 6, :big)
     io.writebits(0b001_1001, 7, :big)
-    io.value.must_equal [0b0101_0100, 0b1100_1000].pack("CC")
+    _(io.value).must_equal [0b0101_0100, 0b1100_1000].pack("CC")
   end
 
   it "writes two bitfields totalling more than 2 bytes" do
     io.writebits(0b01_0111, 6, :big)
     io.writebits(0b1_0010_1001_1001, 13, :big)
-    io.value.must_equal [0b0101_1110, 0b0101_0011, 0b0010_0000].pack("CCC")
+    _(io.value).must_equal [0b0101_1110, 0b0101_0011, 0b0010_0000].pack("CCC")
   end
 
   it "pads unused bits when writing bytes" do
@@ -504,7 +504,7 @@ describe BinData::IO::Write, "writing bits in big endian" do
     io.writebytes([0b1011_1111].pack("C"))
     io.writebits(0b01, 2, :big)
 
-    io.value.must_equal [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
+    _(io.value).must_equal [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
   end
 end
 
@@ -513,35 +513,35 @@ describe BinData::IO::Write, "writing bits in little endian" do
 
   it "writes a bitfield less than 1 byte" do
     io.writebits(0b010, 3, :little)
-    io.value.must_equal [0b0000_0010].pack("C")
+    _(io.value).must_equal [0b0000_0010].pack("C")
   end
 
   it "writes a bitfield more than 1 byte" do
     io.writebits(0b10_1001_1101, 10, :little)
-    io.value.must_equal [0b1001_1101, 0b0000_0010].pack("CC")
+    _(io.value).must_equal [0b1001_1101, 0b0000_0010].pack("CC")
   end
 
   it "writes a bitfield more than 2 bytes" do
     io.writebits(0b101_1000_0010_1001_1101, 19, :little)
-    io.value.must_equal [0b1001_1101, 0b1000_0010, 0b0000_0101].pack("CCC")
+    _(io.value).must_equal [0b1001_1101, 0b1000_0010, 0b0000_0101].pack("CCC")
   end
 
   it "writes two bitfields totalling less than 1 byte" do
     io.writebits(0b1_1001, 5, :little)
     io.writebits(0b00, 2, :little)
-    io.value.must_equal [0b0001_1001].pack("C")
+    _(io.value).must_equal [0b0001_1001].pack("C")
   end
 
   it "writes two bitfields totalling more than 1 byte" do
     io.writebits(0b01_0101, 6, :little)
     io.writebits(0b001_1001, 7, :little)
-    io.value.must_equal [0b0101_0101, 0b0000_0110].pack("CC")
+    _(io.value).must_equal [0b0101_0101, 0b0000_0110].pack("CC")
   end
 
   it "writes two bitfields totalling more than 2 bytes" do
     io.writebits(0b01_0111, 6, :little)
     io.writebits(0b1_0010_1001_1001, 13, :little)
-    io.value.must_equal [0b0101_0111, 0b1010_0110, 0b0000_0100].pack("CCC")
+    _(io.value).must_equal [0b0101_0111, 0b1010_0110, 0b0000_0100].pack("CCC")
   end
 
   it "pads unused bits when writing bytes" do
@@ -549,7 +549,7 @@ describe BinData::IO::Write, "writing bits in little endian" do
     io.writebytes([0b1011_1111].pack("C"))
     io.writebits(0b01, 2, :little)
 
-    io.value.must_equal [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
+    _(io.value).must_equal [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
   end
 end
 
@@ -560,8 +560,8 @@ describe BinData::IO::Read, "with changing endian" do
     str = [b1, b2].pack("CC")
     io = BinData::IO::Read.new(str)
 
-    io.readbits(3, :big).must_equal 0b011
-    io.readbits(4, :little).must_equal 0b0010
+    _(io.readbits(3, :big)).must_equal 0b011
+    _(io.readbits(4, :little)).must_equal 0b0010
   end
 end
 
@@ -570,6 +570,6 @@ describe BinData::IO::Write, "with changing endian" do
     io = BitWriterHelper.new
     io.writebits(0b110, 3, :big)
     io.writebits(0b010, 3, :little)
-    io.value.must_equal [0b1100_0000, 0b0000_0010].pack("CC")
+    _(io.value).must_equal [0b1100_0000, 0b0000_0010].pack("CC")
   end
 end