bindata 1.5.1 → 1.6.0

data/{spec/spec_common.rb → test/common.rb}

@@ -1,9 +1,10 @@
-$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
-
-require 'rspec'
-require 'rspec/autorun'
+require 'rubygems'
+require 'minitest/autorun'
 require 'stringio'
 
+$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
+require 'bindata'
+
 class Object
   def expose_methods_for_testing
     cls = (Class === self) ? self : (class << self ; self; end)
@@ -27,25 +28,23 @@ class StringIO
   end
 end
 
-def exception_line(ex)
-  idx = ex.backtrace.find_index { |bt| /:in `should'$/ =~ bt }
+class ExampleSingle < BinData::BasePrimitive
+  def self.io_with_value(val)
+    BinData::IO.new([val].pack("V"))
+  end
 
-  if idx
-    line_num_regex = /.*:(\d+)(:.*|$)/
+  private
 
-    err_line = line_num_regex.match(ex.backtrace[0])[1].to_i
-    ref_line = line_num_regex.match(ex.backtrace[idx + 1])[1].to_i
+  def value_to_binary_string(val)
+    [val].pack("V")
+  end
 
-    err_line - ref_line
-  else
-    raise "Required calling pattern is lambda { xxx }.should raise_error_on_line(...)"
+  def read_and_return_value(io)
+    io.readbytes(4).unpack("V").at(0)
   end
-end
 
-def raise_error_on_line(exception, line, &block)
-  raise_exception(exception) do |err|
-    exception_line(err).should == line
-    block.call(err) if block_given?
+  def sensible_default
+    0
   end
 end
 
@@ -56,3 +55,19 @@ def binary(str)
     str
   end
 end
+
+module Kernel
+  def must_raise_on_line(exp, line, msg = nil)
+    ex = self.must_raise exp
+    ex.message.must_equal msg if msg
+
+    idx = ex.backtrace.find_index { |bt| /:in `must_raise_on_line'$/ =~ bt }
+
+    line_num_regex = /.*:(\d+)(:.*|$)/
+    err_line = line_num_regex.match(ex.backtrace[0])[1].to_i
+    ref_line = line_num_regex.match(ex.backtrace[idx + 1])[1].to_i
+
+    (err_line - ref_line).must_equal line
+  end
+end
+

data/test/count_bytes_remaining_test.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe BinData::CountBytesRemaining do
+  let(:obj) { BinData::CountBytesRemaining.new }
+
+  it "initial state" do
+    obj.must_equal 0
+    obj.num_bytes.must_equal 0
+  end
+
+  it "counts till end of stream" do
+    data = "abcdefghij"
+    obj.read(data).must_equal 10
+  end
+
+  it "does not read any data" do
+    io = StringIO.new "abcdefghij"
+    obj.read(io)
+
+    io.pos.must_equal 0
+  end
+
+  it "does not write any data" do
+    obj.to_binary_s.must_equal ""
+  end
+
+  it "allows setting value for completeness" do
+    obj.assign("123")
+    obj.must_equal "123"
+    obj.to_binary_s.must_equal ""
+  end
+
+  it "accepts BinData::BasePrimitive parameters" do
+    count = BinData::CountBytesRemaining.new(:assert => 2)
+    lambda {
+      count.read("xyz")
+    }.must_raise BinData::ValidityError
+  end
+end

data/{spec/deprecated_spec.rb → test/deprecated_test.rb}

@@ -1,8 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require File.expand_path(File.join(File.dirname(__FILE__), "example"))
-require 'bindata'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
 describe BinData::Base, "when defining" do
   it "fails if #initialize is overridden" do
@@ -12,9 +10,9 @@ describe BinData::Base, "when defining" do
       end
     end
 
-    expect {
+    lambda {
       BaseWithInitialize.new
-    }.to raise_error
+    }.must_raise RuntimeError
   end
 
   it "handles if #initialize is naively renamed to #initialize_instance" do
@@ -24,8 +22,8 @@ describe BinData::Base, "when defining" do
       end
     end
 
-    expect {
+    lambda {
       BaseWithInitializeInstance.new
-    }.to raise_error
+    }.must_raise RuntimeError
   end
 end

data/test/float_test.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+module FloatTest
+  def test_num_bytes
+    @obj.num_bytes.must_equal 4
+  end
+
+  def test_writing_then_reading
+    @obj.value_read_from_written.must_be_close_to Math::PI, 0.000001
+  end
+end
+
+module DoubleTest
+  def test_num_bytes
+    @obj.num_bytes.must_equal 8
+  end
+
+  def test_writing_then_reading
+    @obj.value_read_from_written.must_be_close_to Math::PI, 0.0000000000000001
+  end
+end
+
+describe "A FloatLe" do
+  include FloatTest
+
+  before do
+    @obj = BinData::FloatLe.new(Math::PI)
+  end
+
+  it "#to_binary_s" do
+    @obj.to_binary_s.must_equal [Math::PI].pack('e')
+  end
+end
+
+describe "A FloatBe" do
+  include FloatTest
+
+  before do
+    @obj = BinData::FloatBe.new(Math::PI)
+  end
+
+  it "#to_binary_s" do
+    @obj.to_binary_s.must_equal [Math::PI].pack('g')
+  end
+end
+
+describe "A DoubleLe" do
+  include DoubleTest
+
+  before do
+    @obj = BinData::DoubleLe.new(Math::PI)
+  end
+
+  it "#to_binary_s" do
+    @obj.to_binary_s.must_equal [Math::PI].pack('E')
+  end
+end
+
+
+describe "A DoubleBe" do
+  include DoubleTest
+
+  before do
+    @obj = BinData::DoubleBe.new(Math::PI)
+  end
+
+  it "#to_binary_s" do
+    @obj.to_binary_s.must_equal [Math::PI].pack('G')
+  end
+end

data/{spec/int_spec.rb → test/int_test.rb}

@@ -1,93 +1,92 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
-shared_examples "All Integers" do
+module AllIntegers
 
-  it "have correct num_bytes" do
+  def test_have_correct_num_bytes
     all_classes do |int_class|
-      int_class.new.num_bytes.should == @nbytes
+      int_class.new.num_bytes.must_equal @nbytes
     end
   end
 
-  it "have a sensible value of zero" do
+  def test_have_a_sensible_value_of_zero
     all_classes do |int_class|
-      int_class.new.should be_zero
+      int_class.new.must_equal 0
     end
   end
 
-  it "avoid underflow" do
+  def test_avoid_underflow
     all_classes do |int_class|
       subject = int_class.new
       subject.assign(min_value - 1)
 
-      subject.should == min_value
+      subject.must_equal min_value
     end
   end
 
-  it "avoid overflow" do
+  def test_avoid_overflow
     all_classes do |int_class|
       subject = int_class.new
       subject.assign(max_value + 1)
 
-      subject.should == max_value
+      subject.must_equal max_value
     end
   end
 
-  it "assign values" do
+  def test_assign_values
     all_classes do |int_class|
       subject = int_class.new
       test_int = gen_test_int
       subject.assign(test_int)
 
-      subject.should == test_int
+      subject.must_equal test_int
     end
   end
 
-  it "assign values from other int objects" do
+  def test_assign_values_from_other_int_objects
     all_classes do |int_class|
       src = int_class.new
       src.assign(gen_test_int)
 
       subject = int_class.new
       subject.assign(src)
-      subject.should == src
+      subject.must_equal src
     end
   end
 
-  it "symmetrically read and write a +ve number" do
+  def test_symmetrically_read_and_write_a_positive_number
     all_classes do |int_class|
       subject = int_class.new
       subject.assign(gen_test_int)
 
-      subject.value_read_from_written.should == subject
+      subject.value_read_from_written.must_equal subject
     end
   end
 
-  it "symmetrically read and write a -ve number" do
+  def test_symmetrically_read_and_write_a_negative_number
     all_classes do |int_class|
       if @signed
         subject = int_class.new
         subject.assign(-gen_test_int)
 
-        subject.value_read_from_written.should == subject
+        subject.value_read_from_written.must_equal subject
       end
     end
   end
 
-  it "convert a +ve number to string" do
+  def test_convert_a_positive_number_to_string
     all_classes do |int_class|
       val = gen_test_int
 
       subject = int_class.new
       subject.assign(val)
 
-      subject.to_binary_s.should == int_to_binary_str(val)
+      subject.to_binary_s.must_equal int_to_binary_str(val)
     end
   end
 
-  it "convert a -ve number to string" do
+  def test_convert_a_negative_number_to_string
     all_classes do |int_class|
       if @signed
         val = -gen_test_int
@@ -95,7 +94,7 @@ shared_examples "All Integers" do
         subject = int_class.new
         subject.assign(val)
 
-        subject.to_binary_s.should == int_to_binary_str(val)
+        subject.to_binary_s.must_equal int_to_binary_str(val)
       end
     end
   end
@@ -156,9 +155,9 @@ shared_examples "All Integers" do
 end
 
 describe "All signed big endian integers" do
-  include_examples "All Integers"
+  include AllIntegers
 
-  before(:all) do
+  before do
     @endian = :big
     @signed = true
     @ints = create_mapping_of_class_to_nbits(@endian, @signed)
@@ -166,9 +165,9 @@ describe "All signed big endian integers" do
 end
 
 describe "All unsigned big endian integers" do
-  include_examples "All Integers"
+  include AllIntegers
 
-  before(:all) do
+  before do
     @endian = :big
     @signed = false
     @ints = create_mapping_of_class_to_nbits(@endian, @signed)
@@ -176,9 +175,9 @@ describe "All unsigned big endian integers" do
 end
 
 describe "All signed little endian integers" do
-  include_examples "All Integers"
+  include AllIntegers
 
-  before(:all) do
+  before do
     @endian = :little
     @signed = true
     @ints = create_mapping_of_class_to_nbits(@endian, @signed)
@@ -186,9 +185,9 @@ describe "All signed little endian integers" do
 end
 
 describe "All unsigned little endian integers" do
-  include_examples "All Integers"
+  include AllIntegers
 
-  before(:all) do
+  before do
     @endian = :little
     @signed = false
     @ints = create_mapping_of_class_to_nbits(@endian, @signed)
@@ -197,20 +196,12 @@ end
 
 describe "Custom defined integers" do
   it "fail unless bits are a multiple of 8" do
-    expect {
-      BinData::Uint7le
-    }.to raise_error
+    lambda { BinData::Uint7le }.must_raise NameError
 
-    expect {
-      BinData::Uint7be
-    }.to raise_error
+    lambda { BinData::Uint7be }.must_raise NameError
 
-    expect {
-      BinData::Int7le
-    }.to raise_error
+    lambda { BinData::Int7le }.must_raise NameError
 
-    expect {
-      BinData::Int7be
-    }.to raise_error
+    lambda { BinData::Int7be }.must_raise NameError
   end
 end

data/{spec/io_spec.rb → test/io_test.rb}

@@ -1,10 +1,9 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/io'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
 describe BinData::IO, "reading from non seekable stream" do
-  before(:each) do
+  before do
     @rd, @wr = IO::pipe
     if fork
       # parent
@@ -25,23 +24,23 @@ describe BinData::IO, "reading from non seekable stream" do
     end
   end
 
-  after(:each) do
+  after do
     @rd.close
     Process.wait
   end
 
   it "always has an offset of 0" do
     @io.readbytes(10)
-    @io.offset.should == 0
+    @io.offset.must_equal 0
   end
 
   it "seeks correctly" do
     @io.seekbytes(4999)
-    @io.readbytes(5).should == "abbbb"
+    @io.readbytes(5).must_equal "abbbb"
   end
 
   it "returns zero for num bytes remaining" do
-    @io.num_bytes_remaining.should == 0
+    @io.num_bytes_remaining.must_equal 0
   end
 end
 
@@ -50,54 +49,54 @@ describe BinData::IO, "when reading" do
   let(:io) { BinData::IO.new(stream) }
 
   it "wraps strings in StringIO" do
-    io.raw_io.class.should == StringIO
+    io.raw_io.class.must_equal StringIO
   end
 
   it "does not wrap IO objects" do
-    io.raw_io.should == stream
+    io.raw_io.must_equal stream
   end
 
   it "raises error when io is BinData::IO" do
-    expect {
+    lambda {
       BinData::IO.new(BinData::IO.new(""))
-    }.to raise_error(ArgumentError)
+    }.must_raise ArgumentError
   end
 
   it "returns correct offset" do
     stream.seek(3, IO::SEEK_CUR)
 
-    io.offset.should == 0
-    io.readbytes(4).should == "defg"
-    io.offset.should == 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).should == "cdef"
+    io.readbytes(4).must_equal "cdef"
   end
 
   it "reads all bytes" do
-    io.read_all_bytes.should == "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.should == stream_length - 4
+    io.num_bytes_remaining.must_equal stream_length - 4
   end
 
   it "raises error when reading at eof" do
     io.seekbytes(10)
-    expect {
+    lambda {
       io.readbytes(3)
-    }.to raise_error(EOFError)
+    }.must_raise EOFError
   end
 
   it "raises error on short reads" do
-    expect {
+    lambda {
       io.readbytes(20)
-    }.to raise_error(IOError)
+    }.must_raise IOError
   end
 end
 
@@ -106,26 +105,26 @@ describe BinData::IO, "when writing" do
   let(:io) { BinData::IO.new(stream) }
 
   it "does not wrap IO objects" do
-    io.raw_io.should == stream
+    io.raw_io.must_equal stream
   end
 
   it "raises error when io is BinData::IO" do
-    expect {
+    lambda {
       BinData::IO.new(BinData::IO.new(""))
-    }.to raise_error(ArgumentError)
+    }.must_raise ArgumentError
   end
 
   it "writes correctly" do
     io.writebytes("abcd")
 
-    stream.value.should == "abcd"
+    stream.value.must_equal "abcd"
   end
 
   it "flushes" do
     io.writebytes("abcd")
     io.flush
 
-    stream.value.should == "abcd"
+    stream.value.must_equal "abcd"
   end
 end
 
@@ -136,42 +135,42 @@ describe BinData::IO, "reading bits in big endian" do
   let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
-    io.readbits(3, :big).should == 0b111
+    io.readbits(3, :big).must_equal 0b111
   end
 
   it "reads a bitfield more than 1 byte" do
-    io.readbits(10, :big).should == 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).should == 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).should == 0b1111_1
-    io.readbits(2, :big).should == 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).should == 0b1111_10
-    io.readbits(8, :big).should == 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).should == 0b1111_101
-    io.readbits(12, :big).should == 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).should == 0b111
-    io.readbytes(1).should == [b2].pack("C")
-    io.readbits(2, :big).should == 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).should == 0b111
+    io.readbits(3, :big).must_equal 0b111
     io.reset_read_bits
-    io.readbits(3, :big).should == 0b110
+    io.readbits(3, :big).must_equal 0b110
   end
 end
 
@@ -182,42 +181,42 @@ describe BinData::IO, "reading bits in little endian" do
   let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
-    io.readbits(3, :little).should == 0b010
+    io.readbits(3, :little).must_equal 0b010
   end
 
   it "reads a bitfield more than 1 byte" do
-    io.readbits(10, :little).should == 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).should == 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).should == 0b1_1010
-    io.readbits(2, :little).should == 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).should == 0b11_1010
-    io.readbits(8, :little).should == 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).should == 0b111_1010
-    io.readbits(12, :little).should == 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).should == 0b010
-    io.readbytes(1).should == [b2].pack("C")
-    io.readbits(2, :little).should == 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).should == 0b010
+    io.readbits(3, :little).must_equal 0b010
     io.reset_read_bits
-    io.readbits(3, :little).should == 0b110
+    io.readbits(3, :little).must_equal 0b110
   end
 end
 
@@ -247,35 +246,35 @@ describe BinData::IO, "writing bits in big endian" do
 
   it "writes a bitfield less than 1 byte" do
     io.writebits(0b010, 3, :big)
-    io.value.should == [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.should == [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.should == [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.should == [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.should == [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.should == [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
@@ -283,7 +282,7 @@ describe BinData::IO, "writing bits in big endian" do
     io.writebytes([0b1011_1111].pack("C"))
     io.writebits(0b01, 2, :big)
 
-    io.value.should == [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
+    io.value.must_equal [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
   end
 end
 
@@ -292,35 +291,35 @@ describe BinData::IO, "writing bits in little endian" do
 
   it "writes a bitfield less than 1 byte" do
     io.writebits(0b010, 3, :little)
-    io.value.should == [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.should == [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.should == [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.should == [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.should == [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.should == [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
@@ -328,7 +327,7 @@ describe BinData::IO, "writing bits in little endian" do
     io.writebytes([0b1011_1111].pack("C"))
     io.writebits(0b01, 2, :little)
 
-    io.value.should == [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
+    io.value.must_equal [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
   end
 end
 
@@ -339,14 +338,14 @@ describe BinData::IO, "with changing endian" do
     str = [b1, b2].pack("CC")
     io = BinData::IO.new(str)
 
-    io.readbits(3, :big).should == 0b011
-    io.readbits(4, :little).should == 0b0010
+    io.readbits(3, :big).must_equal 0b011
+    io.readbits(4, :little).must_equal 0b0010
   end
 
   it "does not mix different endianess when writing" do
     io = BitWriterHelper.new
     io.writebits(0b110, 3, :big)
     io.writebits(0b010, 3, :little)
-    io.value.should == [0b1100_0000, 0b0000_0010].pack("CC")
+    io.value.must_equal [0b1100_0000, 0b0000_0010].pack("CC")
   end
 end