bindata 1.4.3 → 1.4.4

data/spec/base_spec.rb

@@ -21,31 +21,31 @@ describe BinData::Base, "all subclasses" do
 
   subject { SubClassOfBase.new }
 
-  it "should raise errors on unimplemented methods" do
-    lambda { subject.clear         }.should raise_error(NotImplementedError)
-    lambda { subject.clear?        }.should raise_error(NotImplementedError)
-    lambda { subject.assign(nil)   }.should raise_error(NotImplementedError)
-    lambda { subject.snapshot      }.should raise_error(NotImplementedError)
-    lambda { subject.do_read(nil)  }.should raise_error(NotImplementedError)
-    lambda { subject.do_write(nil) }.should raise_error(NotImplementedError)
-    lambda { subject.do_num_bytes  }.should raise_error(NotImplementedError)
+  it "raises errors on unimplemented methods" do
+    expect { subject.clear         }.to raise_error(NotImplementedError)
+    expect { subject.clear?        }.to raise_error(NotImplementedError)
+    expect { subject.assign(nil)   }.to raise_error(NotImplementedError)
+    expect { subject.snapshot      }.to raise_error(NotImplementedError)
+    expect { subject.do_read(nil)  }.to raise_error(NotImplementedError)
+    expect { subject.do_write(nil) }.to raise_error(NotImplementedError)
+    expect { subject.do_num_bytes  }.to raise_error(NotImplementedError)
   end
 end
 
 describe BinData::Base, "with parameters" do
-  it "should raise error if parameter name is invalid" do
-    lambda {
+  it "raises error when parameter name is invalid" do
+    expect {
       class InvalidParameterNameBase < BinData::Base
         optional_parameter :eval # i.e. Kernel#eval
       end
-    }.should raise_error(NameError)
+    }.to raise_error(NameError)
   end
 
-  it "should raise error if parameter has nil value" do
-    lambda { BaseStub.new(:a => nil) }.should raise_error(ArgumentError)
+  it "raises an error when parameter has nil value" do
+    expect { BaseStub.new(:a => nil) }.to raise_error(ArgumentError)
   end
 
-  it "should convert parameter keys to symbols" do
+  it "converts parameter keys to symbols" do
     subject = BaseStub.new('a' => 3)
     subject.should have_parameter(:a)
   end
@@ -57,18 +57,18 @@ describe BinData::Base, "with mandatory parameters" do
     mandatory_parameter :p2
   end
 
-  it "should ensure that all mandatory parameters are present" do
+  it "ensures that all mandatory parameters are present" do
     params = {:p1 => "a", :p2 => "b" }
-    lambda { MandatoryBase.new(params) }.should_not raise_error
+    expect { MandatoryBase.new(params) }.not_to raise_error
   end
 
-  it "should fail if not all mandatory parameters are present" do
+  it "fails when only some mandatory parameters are present" do
     params = {:p1 => "a", :xx => "b" }
-    lambda { MandatoryBase.new(params) }.should raise_error(ArgumentError)
+    expect { MandatoryBase.new(params) }.to raise_error(ArgumentError)
   end
 
-  it "should fail if no mandatory parameters are present" do
-    lambda { MandatoryBase.new() }.should raise_error(ArgumentError)
+  it "fails when no mandatory parameters are present" do
+    expect { MandatoryBase.new() }.to raise_error(ArgumentError)
   end
 end
 
@@ -77,12 +77,12 @@ describe BinData::Base, "with default parameters" do
     default_parameter :p1 => "a"
   end
 
-  it "should use default parameters when not specified" do
+  it "uses default parameters when not specified" do
     subject = DefaultBase.new
     subject.eval_parameter(:p1).should == "a"
   end
 
-  it "should be able to override default parameters" do
+  it "can override default parameters" do
     subject = DefaultBase.new(:p1 => "b")
     subject.eval_parameter(:p1).should == "b"
   end
@@ -94,17 +94,17 @@ describe BinData::Base, "with mutually exclusive parameters" do
     mutually_exclusive_parameters :p1, :p2
   end
 
-  it "should not fail when neither of those parameters are present" do
-    lambda { MutexParamBase.new }.should_not raise_error
+  it "does not fail when neither of those parameters are present" do
+    expect { MutexParamBase.new }.not_to raise_error
   end
 
-  it "should not fail when only one of those parameters is present" do
-    lambda { MutexParamBase.new(:p1 => "a") }.should_not raise_error
-    lambda { MutexParamBase.new(:p2 => "b") }.should_not raise_error
+  it "does not fail when only one of those parameters is present" do
+    expect { MutexParamBase.new(:p1 => "a") }.not_to raise_error
+    expect { MutexParamBase.new(:p2 => "b") }.not_to raise_error
   end
 
-  it "should fail when both those parameters are present" do
-    lambda { MutexParamBase.new(:p1 => "a", :p2 => "b") }.should raise_error(ArgumentError)
+  it "fails when both those parameters are present" do
+    expect { MutexParamBase.new(:p1 => "a", :p2 => "b") }.to raise_error(ArgumentError)
   end
 end
 
@@ -115,7 +115,7 @@ describe BinData::Base, "with multiple parameters" do
     optional_parameter  :p3
   end
 
-  it "should identify internally accepted parameters" do
+  it "identifies internally accepted parameters" do
     accepted = WithParamBase.accepted_parameters.all
     accepted.should include(:p1)
     accepted.should include(:p2)
@@ -129,21 +129,21 @@ describe BinData::Base, "with multiple parameters" do
       WithParamBase.new(params)
     }
 
-    it "should evaluate parameters" do
+    it "evaluates parameters" do
       subject.eval_parameter(:p1).should == 1
       subject.eval_parameter(:p2).should == 2
-      lambda { subject.eval_parameter(:p3) }.should raise_error(NoMethodError)
+      expect { subject.eval_parameter(:p3) }.to raise_error(NoMethodError)
       subject.eval_parameter(:p4).should == 4
     end
 
-    it "should get parameters without evaluating" do
+    it "gets parameters without evaluating" do
       subject.get_parameter(:p1).should == 1
       subject.get_parameter(:p2).should == 2
       subject.get_parameter(:p3).should == :xx
       subject.get_parameter(:p4).should respond_to(:arity)
     end
 
-    it "should have parameters" do
+    it "has parameters" do
       subject.should have_parameter(:p1)
       subject.should have_parameter(:p2)
       subject.should have_parameter(:p3)
@@ -172,7 +172,7 @@ describe BinData::Base, "when initializing" do
     end
   end
 
-  it "should call both #initialize_xxx methods when initializing" do
+  it "calls both #initialize_xxx methods" do
     BaseInit.recorded_calls {
       BaseInit.new
     }.should == [:initialize_shared_instance, :initialize_instance]
@@ -182,7 +182,7 @@ describe BinData::Base, "when initializing" do
     subject { BaseInit.new(:check_offset => 1) }
 
     describe "#new" do
-      it "should call #initialize_instance" do
+      it "calls #initialize_instance" do
         obj = subject
 
         BaseInit.recorded_calls {
@@ -190,24 +190,24 @@ describe BinData::Base, "when initializing" do
         }.should == [:initialize_instance]
       end
 
-      it "should copy parameters" do
+      it "copies parameters" do
         obj = subject.new
         obj.eval_parameter(:check_offset).should == 1
       end
 
-      it "should perform action for :check_offset" do
+      it "performs action for :check_offset" do
         obj = subject.new
-        lambda {
+        expect {
           obj.read("abc")
-        }.should raise_error(BinData::ValidityError)
+        }.to raise_error(BinData::ValidityError)
       end
 
-      it "should assign value" do
+      it "assigns value" do
         obj = subject.new(3)
         obj.snapshot.should == 3
       end
 
-      it "should set parent" do
+      it "sets parent" do
         obj = subject.new(3, "p")
         obj.parent.should == "p"
       end
@@ -215,21 +215,18 @@ describe BinData::Base, "when initializing" do
   end
 end
 
-describe BinData::Base, "as a factory" do
-end
-
 describe BinData::Base, "as black box" do
   context "class methods" do
-    it "should return bindata_name" do
+    it "returns bindata_name" do
       BaseStub.bindata_name.should == "base_stub"
     end
 
-    it "should instantiate self for ::read" do
+    it "instantiates self for ::read" do
       BaseStub.read("").class.should == BaseStub
     end
   end
 
-  it "should access parent" do
+  it "accesses parent" do
     parent = BaseStub.new
     child = BaseStub.new(nil, parent)
     child.parent.should == parent
@@ -237,25 +234,25 @@ describe BinData::Base, "as black box" do
 
   subject { BaseStub.new }
 
-  it "should return self for #read" do
+  it "returns self for #read" do
     subject.read("").should == subject
   end
 
-  it "should return self for #write" do
+  it "returns self for #write" do
     subject.write("").should == subject
   end
 
-  it "should forward #inspect to snapshot" do
+  it "forwards #inspect to snapshot" do
     subject.stub(:snapshot).and_return([1, 2, 3])
     subject.inspect.should == subject.snapshot.inspect
   end
 
-  it "should forward #to_s to snapshot" do
+  it "forwards #to_s to snapshot" do
     subject.stub(:snapshot).and_return([1, 2, 3])
     subject.to_s.should == subject.snapshot.to_s
   end
 
-  it "should pretty print object as snapshot" do
+  it "pretty prints object as snapshot" do
     subject.stub(:snapshot).and_return([1, 2, 3])
     actual_io = StringIO.new
     expected_io = StringIO.new
@@ -267,7 +264,7 @@ describe BinData::Base, "as black box" do
     actual_io.value.should == expected_io.value
   end
 
-  it "should write the same as to_binary_s" do
+  it "writes the same as to_binary_s" do
     class WriteToSBase < BaseStub
       def do_write(io) io.writebytes("abc"); end
     end
@@ -282,23 +279,23 @@ end
 describe BinData::Base, "as white box" do
   subject { BaseStub.new }
 
-  it "should forward read to do_read" do
+  it "forwards read to do_read" do
     subject.should_receive(:clear).ordered
     subject.should_receive(:do_read).ordered
     subject.read(nil)
   end
 
-  it "should forward write to do_write" do
+  it "forwards write to do_write" do
     subject.should_receive(:do_write)
     subject.write(nil)
   end
 
-  it "should forward num_bytes to do_num_bytes" do
+  it "forwards num_bytes to do_num_bytes" do
     subject.should_receive(:do_num_bytes).and_return(42)
     subject.num_bytes.should == 42
   end
 
-  it "should round up fractional num_bytes" do
+  it "rounds up fractional num_bytes" do
     subject.should_receive(:do_num_bytes).and_return(42.1)
     subject.num_bytes.should == 43
   end
@@ -325,55 +322,55 @@ describe BinData::Base, "checking offsets" do
   let(:io) { StringIO.new("12345678901234567890") }
 
   context "with :check_offset" do
-    it "should fail if offset is incorrect" do
+    it "fails when offset is incorrect" do
       io.seek(2)
       subject = TenByteOffsetBase.create(:check_offset => 8)
-      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+      expect { subject.read(io) }.to raise_error(BinData::ValidityError)
     end
 
-    it "should succeed if offset is correct" do
+    it "succeeds when offset is correct" do
       io.seek(3)
       subject = TenByteOffsetBase.create(:check_offset => 10)
-      lambda { subject.read(io) }.should_not raise_error
+      expect { subject.read(io) }.not_to raise_error
     end
 
-    it "should fail if :check_offset fails" do
+    it "fails when :check_offset fails" do
       io.seek(4)
       subject = TenByteOffsetBase.create(:check_offset => lambda { offset == 11 } )
-      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+      expect { subject.read(io) }.to raise_error(BinData::ValidityError)
     end
 
-    it "should succeed if :check_offset succeeds" do
+    it "succeeds when :check_offset succeeds" do
       io.seek(5)
       subject = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 } )
-      lambda { subject.read(io) }.should_not raise_error
+      expect { subject.read(io) }.not_to raise_error
     end
   end
 
   context "with :adjust_offset" do
-    it "should be mutually exclusive with :check_offset" do
+    it "is mutually exclusive with :check_offset" do
       params = { :check_offset => 8, :adjust_offset => 8 }
-      lambda { TenByteOffsetBase.create(params) }.should raise_error(ArgumentError)
+      expect { TenByteOffsetBase.create(params) }.to raise_error(ArgumentError)
     end
 
-    it "should adjust if offset is incorrect" do
+    it "adjust offset when incorrect" do
       io.seek(2)
       subject = TenByteOffsetBase.create(:adjust_offset => 13)
       subject.read(io)
       io.pos.should == (2 + 13)
     end
 
-    it "should succeed if offset is correct" do
+    it "succeeds when offset is correct" do
       io.seek(3)
       subject = TenByteOffsetBase.create(:adjust_offset => 10)
-      lambda { subject.read(io) }.should_not raise_error
+      expect { subject.read(io) }.not_to raise_error
       io.pos.should == (3 + 10)
     end
 
-    it "should fail if cannot adjust offset" do
+    it "fails if cannot adjust offset" do
       io.seek(4)
       subject = TenByteOffsetBase.create(:adjust_offset => -5)
-      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+      expect { subject.read(io) }.to raise_error(BinData::ValidityError)
     end
   end
 end

data/spec/bits_spec.rb

@@ -6,7 +6,7 @@ require 'bindata/bits'
 describe "Bits of size 1" do
   let(:bit_classes) { [BinData::Bit1, BinData::Bit1le] }
 
-  it "should accept true as value" do
+  it "accept true as value" do
     bit_classes.each do |bit_class|
       subject = bit_class.new
       subject.assign(true)
@@ -14,7 +14,7 @@ describe "Bits of size 1" do
     end
   end
 
-  it "should accept false as value" do
+  it "accept false as value" do
     bit_classes.each do |bit_class|
       subject = bit_class.new
       subject.assign(false)
@@ -22,7 +22,7 @@ describe "Bits of size 1" do
     end
   end
 
-  it "should accept nil as value" do
+  it "accept nil as value" do
     bit_classes.each do |bit_class|
       subject = bit_class.new
       subject.assign(nil)
@@ -31,15 +31,15 @@ describe "Bits of size 1" do
   end
 end
 
-share_examples_for "All bitfields" do
+shared_examples "All bitfields" do
 
-  it "should have a sensible value of zero" do
+  it "have a sensible value of zero" do
     all_classes do |bit_class|
       bit_class.new.should be_zero
     end
   end
 
-  it "should avoid underflow" do
+  it "avoid underflow" do
     all_classes do |bit_class|
       subject = bit_class.new
 
@@ -48,7 +48,7 @@ share_examples_for "All bitfields" do
     end
   end
 
-  it "should avoid overflow" do
+  it "avoid overflow" do
     all_classes do |bit_class|
       subject = bit_class.new
 
@@ -57,7 +57,7 @@ share_examples_for "All bitfields" do
     end
   end
 
-  it "should assign values" do
+  it "assign values" do
     all_classes do |bit_class|
       some_values_within_range.each do |val|
         subject = bit_class.new
@@ -68,7 +68,7 @@ share_examples_for "All bitfields" do
     end
   end
 
-  it "should assign values from other bit objects" do
+  it "assign values from other bit objects" do
     all_classes do |bit_class|
       some_values_within_range.each do |val|
         subject = bit_class.new
@@ -79,7 +79,7 @@ share_examples_for "All bitfields" do
     end
   end
 
-  it "should have symmetric #read and #write" do
+  it "symmetrically #read and #write" do
     all_classes do |bit_class|
       some_values_within_range.each do |val|
         subject = bit_class.new
@@ -129,13 +129,13 @@ def generate_bit_classes_to_test(endian)
 end
 
 describe "Big endian bitfields" do
-  it_should_behave_like "All bitfields"
+  include_examples "All bitfields"
 
   before(:all) do
     @bits = generate_bit_classes_to_test(:big)
   end
 
-  it "should read big endian value" do
+  it "read big endian values" do
     @bits.each_pair do |bit_class, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
@@ -146,13 +146,13 @@ describe "Big endian bitfields" do
 end
 
 describe "Little endian bitfields" do
-  it_should_behave_like "All bitfields"
+  include_examples "All bitfields"
 
   before(:all) do
     @bits = generate_bit_classes_to_test(:little)
   end
 
-  it "should read little endian value" do
+  it "read little endian values" do
     @bits.each_pair do |bit_class, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)