bindata 1.4.3 → 1.4.4

data/spec/alignment_spec.rb

@@ -12,14 +12,14 @@ describe BinData::ResumeByteAlignment do
 
   subject { ResumeAlignmentRecord.new }
 
-  it "should reset read alignment" do
+  it "resets read alignment" do
     subject.read "\x12\x34"
 
     subject.a.should == 1
     subject.b.should == 3
   end
 
-  it "should reset write alignment" do
+  it "resets write alignment" do
     subject.assign(:a => 2, :b => 7)
 
     subject.to_binary_s.should == "\x20\x70"
@@ -27,12 +27,12 @@ describe BinData::ResumeByteAlignment do
 end
 
 describe BinData::BitAligned do
-  it "should not apply to BinData::Primitives" do
-    lambda {
+  it "does not apply to BinData::Primitives" do
+    expect {
       class BitAlignedPrimitive < BinData::Primitive
         bit_aligned
       end
-    }.should raise_error
+    }.to raise_error
   end
 
   class BitString < BinData::String
@@ -49,12 +49,12 @@ describe BinData::BitAligned do
 
   its(:num_bytes) { should == 3 }
 
-  it "should read" do
+  it "reads as expected" do
     subject.read("\x56\x36\x42")
     subject.should == {"preamble" => 5, "str" => "cd", "afterward" => 2}
   end
 
-  it "should write" do
+  it "writes as expected" do
     subject.assign(:preamble => 5, :str => "ab", :afterward => 1)
     subject.to_binary_s.should == "\x56\x16\x21"
   end

data/spec/array_spec.rb

@@ -4,23 +4,31 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require File.expand_path(File.join(File.dirname(__FILE__), "example"))
 require 'bindata/array'
 require 'bindata/int'
+require 'bindata/string'
 
 describe BinData::Array, "when instantiating" do
-  it "should ensure mandatory parameters are supplied" do
-    args = {}
-    lambda { BinData::Array.new(args) }.should raise_error(ArgumentError)
-    args = {:initial_length => 3}
-    lambda { BinData::Array.new(args) }.should raise_error(ArgumentError)
+  context "with no mandatory parameters supplied" do
+    it "raises an error" do
+      args = {}
+      expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "with some but not all mandatory parameters supplied" do
+    it "raises an error" do
+      args = {:initial_length => 3}
+      expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
+    end
   end
 
-  it "should fail if a given type is unknown" do
+  it "fails if a given type is unknown" do
     args = {:type => :does_not_exist, :initial_length => 3}
-    lambda { BinData::Array.new(args) }.should raise_error(BinData::UnRegisteredTypeError)
+    expect { BinData::Array.new(args) }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should not allow both :initial_length and :read_until" do
+  it "does not allow both :initial_length and :read_until" do
     args = {:initial_length => 3, :read_until => lambda { false } }
-    lambda { BinData::Array.new(args) }.should raise_error(ArgumentError)
+    expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
   end
 end
 
@@ -30,20 +38,14 @@ describe BinData::Array, "with no elements" do
   it { should be_clear }
   it { should be_empty }
   its(:length) { should be_zero }
+  its(:first)  { should be_nil }
+  its(:last)   { should be_nil }
 
-  it "should return nil for the first element" do
-    subject.first.should be_nil
-  end
-
-  it "should return [] for the first n elements" do
+  it "returns [] for the first n elements" do
     subject.first(3).should == []
   end
 
-  it "should return nil for the last element" do
-    subject.last.should be_nil
-  end
-
-  it "should return [] for the last n elements" do
+  it "returns [] for the last n elements" do
     subject.last(3).should == []
   end
 end
@@ -61,83 +63,82 @@ describe BinData::Array, "with several elements" do
   its(:snapshot) { should == [1, 2, 3, 4, 5] }
   its(:inspect) { should == "[1, 2, 3, 4, 5]" }
 
-  it "should coerce to ::Array if required" do
+  it "coerces to ::Array if required" do
     [0].concat(subject).should == [0, 1, 2, 3, 4, 5]
   end
 
-  it "should be able to use methods from Enumerable" do
+  it "uses methods from Enumerable" do
     subject.select { |x| (x % 2) == 0 }.should == [2, 4]
   end
 
-  it "should assign primitive values" do
+  it "assigns primitive values" do
     subject.assign([4, 5, 6])
     subject.should == [4, 5, 6]
   end
 
-  it "should assign bindata objects" do
+  it "assigns bindata objects" do
     subject.assign([ExampleSingle.new(4), ExampleSingle.new(5), ExampleSingle.new(6)])
     subject.should == [4, 5, 6]
   end
 
-  it "should assign bindata array" do
-    array = BinData::Array.new(:type => :example_single)
-    array.push(4, 5, 6)
+  it "assigns a bindata array" do
+    array = BinData::Array.new([4, 5, 6], :type => :example_single)
     subject.assign(array)
     subject.should == [4, 5, 6]
   end
 
-  it "should return the first element" do
+  it "returns the first element" do
     subject.first.should == 1
   end
 
-  it "should return the first n elements" do
+  it "returns the first n elements" do
     subject[0...3].should == [1, 2, 3]
     subject.first(3).should == [1, 2, 3]
     subject.first(99).should == [1, 2, 3, 4, 5]
   end
 
-  it "should return the last element" do
+  it "returns the last element" do
     subject.last.should == 5
     subject[-1].should == 5
   end
 
-  it "should return the last n elements" do
+  it "returns the last n elements" do
     subject.last(3).should == [3, 4, 5]
     subject.last(99).should == [1, 2, 3, 4, 5]
 
     subject[-3, 100].should == [3, 4, 5]
   end
 
-  it "should clear" do
+  it "clears all" do
     subject[1] = 8
     subject.clear
     subject.should == [1, 2, 3, 4, 5]
   end
 
-  it "should clear a single element" do
+  it "clears a single element" do
     subject[1] = 8
     subject[1].clear
     subject[1].should == 2
   end
 
-  it "should be clear if all elements are clear" do
+  it "is clear if all elements are clear" do
     subject[1] = 8
     subject[1].clear
     subject.should be_clear
   end
 
-  it "should test clear status of individual elements" do
+  it "tests clear status of individual elements" do
     subject[1] = 8
     subject[0].should be_clear
     subject[1].should_not be_clear
   end
 
-  it "should be able to directly access elements" do
+  it "directly accesses elements" do
     subject[1] = 8
     subject[1].should == 8
   end
 
-  it "should symmetrically read and write" do
+  it "symmetrically reads and writes" do
     subject[1] = 8
     str = subject.to_binary_s
 
@@ -148,27 +149,27 @@ describe BinData::Array, "with several elements" do
     subject[1].should == 8
   end
 
-  it "should identify index of elements" do
+  it "identifies index of elements" do
     subject.index(3).should == 2
   end
 
-  it "should return nil for index of non existent element" do
+  it "returns nil for index of non existent element" do
     subject.index(42).should be_nil
   end
 
-  it "should have correct debug name" do
+  it "has correct debug name" do
     subject[2].debug_name.should == "obj[2]"
   end
 
-  it "should have correct offset" do
+  it "has correct offset" do
     subject[2].offset.should == ExampleSingle.new.num_bytes * 2
   end
 
-  it "should have correct num_bytes" do
+  it "has correct num_bytes" do
     subject.num_bytes.should == 5 * ExampleSingle.new.num_bytes
   end
 
-  it "should have correct num_bytes for individual elements" do
+  it "has correct num_bytes for individual elements" do
     subject[0].num_bytes.should == ExampleSingle.new.num_bytes
   end
 end
@@ -181,71 +182,71 @@ describe BinData::Array, "when accessing elements" do
     data
   }
 
-  it "should insert with positive indexes" do
+  it "inserts with positive indexes" do
     subject.insert(2, 30, 40)
     subject.snapshot.should == [1, 2, 30, 40, 3, 4, 5]
   end
 
-  it "should insert with negative indexes" do
+  it "inserts with negative indexes" do
     subject.insert(-2, 30, 40)
     subject.snapshot.should == [1, 2, 3, 4, 30, 40, 5]
   end
 
-  it "should push" do
+  it "pushes" do
     subject.push(30, 40)
     subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
   end
 
-  it "should concat" do
+  it "concats" do
     subject.concat([30, 40])
     subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
   end
 
-  it "should unshift" do
+  it "unshifts" do
     subject.unshift(30, 40)
     subject.snapshot.should == [30, 40, 1, 2, 3, 4, 5]
   end
 
-  it "should automatically extend on [index]" do
+  it "automatically extends on [index]" do
     subject[9].should == 10
     subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   end
 
-  it "should automatically extend on []=" do
+  it "automatically extends on []=" do
     subject[9] = 30
     subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
   end
 
-  it "should automatically extend on insert" do
+  it "automatically extends on insert" do
     subject.insert(7, 30, 40)
     subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 30, 40]
   end
 
-  it "should not extend on at" do
+  it "does not extend on at" do
     subject.at(9).should be_nil
     subject.length.should == 5
   end
 
-  it "should not extend on [start, length]" do
+  it "does not extend on [start, length]" do
     subject[9, 2].should be_nil
     subject.length.should == 5
   end
 
-  it "should not extend on [range]" do
+  it "does not extend on [range]" do
     subject[9 .. 10].should be_nil
     subject.length.should == 5
   end
 
-  it "should raise error on bad input to []" do
-    lambda { subject["a"] }.should raise_error(TypeError)
-    lambda { subject[1, "a"] }.should raise_error(TypeError)
+  it "raises error on bad input to []" do
+    expect { subject["a"] }.to raise_error(TypeError)
+    expect { subject[1, "a"] }.to raise_error(TypeError)
   end
 end
 
 describe BinData::Array, "with :read_until" do
 
   context "containing +element+" do
-    it "should read until the sentinel is reached" do
+    it "reads until the sentinel is reached" do
       read_until = lambda { element == 5 }
       subject = BinData::Array.new(:type => :int8, :read_until => read_until)
 
@@ -255,7 +256,7 @@ describe BinData::Array, "with :read_until" do
   end
 
   context "containing +array+ and +index+" do
-    it "should read until the sentinel is reached" do
+    it "reads until the sentinel is reached" do
       read_until = lambda { index >= 2 and array[index - 2] == 5 }
       subject = BinData::Array.new(:type => :int8, :read_until => read_until)
 
@@ -264,25 +265,25 @@ describe BinData::Array, "with :read_until" do
     end
   end
 
-  context "== :eof" do
-    it "should read records until eof" do
+  context ":eof" do
+    it "reads records until eof" do
       subject = BinData::Array.new(:type => :int8, :read_until => :eof)
 
       subject.read "\x01\x02\x03"
       subject.should == [1, 2, 3]
     end
 
-    it "should read records until eof, ignoring partial records" do
+    it "reads records until eof, ignoring partial records" do
       subject = BinData::Array.new(:type => :int16be, :read_until => :eof)
 
       subject.read "\x00\x01\x00\x02\x03"
       subject.should == [1, 2]
     end
 
-    it "should report exceptions" do
+    it "reports exceptions" do
       array_type = [:string, {:read_length => lambda { unknown_variable }}]
       subject = BinData::Array.new(:type => array_type, :read_until => :eof)
-      lambda { subject.read "\x00\x01\x00\x02\x03" }.should raise_error
+      expect { subject.read "\x00\x01\x00\x02\x03" }.to raise_error
     end
   end
 end
@@ -297,7 +298,7 @@ describe BinData::Array, "nested within an Array" do
 
   its(:snapshot) { should == [ [0], [0, 1], [0, 1, 2] ] }
 
-  it "should maintain structure when reading" do
+  it "maintains structure when reading" do
     subject.read "\x04\x05\x06\x07\x08\x09"
     subject.should == [ [4], [5, 6], [7, 8, 9] ]
   end
@@ -311,12 +312,12 @@ describe BinData::Array, "subclassed" do
     uint16 :initial_value => :initial_element_value
   end
 
-  it "should forward parameters" do
+  it "forwards parameters" do
     subject = IntArray.new(:initial_length => 7)
     subject.length.should == 7
   end
 
-  it "should be able to override default parameters" do
+  it "overrides default parameters" do
     subject = IntArray.new(:initial_length => 3, :initial_element_value => 5)
     subject.to_binary_s.should == "\x00\x05\x00\x05\x00\x05"
   end

data/spec/base_primitive_spec.rb

@@ -6,12 +6,10 @@ require 'bindata/base_primitive'
 require 'bindata/io'
 
 describe BinData::BasePrimitive do
-  let(:r) { BinData::RegisteredClasses }
-
-  it "should not be registered" do
-    lambda {
-      r.lookup("BasePrimitive")
-    }.should raise_error(BinData::UnRegisteredTypeError)
+  it "is not registered" do
+    expect {
+      BinData::RegisteredClasses.lookup("BasePrimitive")
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 end
 
@@ -22,20 +20,20 @@ describe BinData::BasePrimitive, "all subclasses" do
 
   subject { SubClassOfBasePrimitive.new }
 
-  it "should raise errors on unimplemented methods" do
-    lambda { subject.value_to_binary_string(nil) }.should raise_error(NotImplementedError)
-    lambda { subject.read_and_return_value(nil) }.should raise_error(NotImplementedError)
-    lambda { subject.sensible_default }.should raise_error(NotImplementedError)
+  it "raise errors on unimplemented methods" do
+    expect { subject.value_to_binary_string(nil) }.to raise_error(NotImplementedError)
+    expect { subject.read_and_return_value(nil) }.to raise_error(NotImplementedError)
+    expect { subject.sensible_default }.to raise_error(NotImplementedError)
   end
 end
 
 describe BinData::BasePrimitive do
-  it "should conform to rule 1 for returning a value" do
+  it "conforms to rule 1 for returning a value" do
     data = ExampleSingle.new(:value => 5)
     data.should == 5
   end
 
-  it "should conform to rule 2 for returning a value" do
+  it "conforms to rule 2 for returning a value" do
     io = ExampleSingle.io_with_value(42)
     data = ExampleSingle.new(:value => 5)
     data.read(io)
@@ -44,26 +42,26 @@ describe BinData::BasePrimitive do
     data.should == 42
   end
 
-  it "should conform to rule 3 for returning a value" do
+  it "conforms to rule 3 for returning a value" do
     data = ExampleSingle.new(:initial_value => 5)
     data.should be_clear
     data.should == 5
   end
 
-  it "should conform to rule 4 for returning a value" do
+  it "conforms to rule 4 for returning a value" do
     data = ExampleSingle.new(:initial_value => 5)
     data.assign(17)
     data.should_not be_clear
     data.should == 17
   end
 
-  it "should conform to rule 5 for returning a value" do
+  it "conforms to rule 5 for returning a value" do
     data = ExampleSingle.new
     data.should be_clear
     data.should == 0
   end
 
-  it "should conform to rule 6 for returning a value" do
+  it "conforms to rule 6 for returning a value" do
     data = ExampleSingle.new
     data.assign(8)
     data.should_not be_clear
@@ -74,53 +72,53 @@ end
 describe ExampleSingle do
   subject { ExampleSingle.new(5) }
 
-  it "should fail when assigning nil values" do
-    lambda { subject.assign(nil) }.should raise_error(ArgumentError)
+  it "fails when assigning nil values" do
+    expect { subject.assign(nil) }.to raise_error(ArgumentError)
   end
 
-  it "should allowing setting and retrieving value" do
+  it "sets and retrieves values" do
     subject.assign(7)
     subject.should == 7
   end
 
-  it "should allowing setting and retrieving BinData::BasePrimitives" do
+  it "sets and retrieves BinData::BasePrimitives" do
     subject.assign(ExampleSingle.new(7))
     subject.should == 7
   end
 
-  it "should respond to known methods" do
+  it "responds to known methods" do
     subject.should respond_to(:num_bytes)
   end
 
-  it "should respond to known methods in #snapshot" do
+  it "responds to known methods in #snapshot" do
     subject.should respond_to(:div)
   end
 
-  it "should not respond to unknown methods in self or #snapshot" do
+  it "does not respond to unknown methods in self or #snapshot" do
     subject.should_not respond_to(:does_not_exist)
   end
 
-  it "should behave as #snapshot" do
+  it "behaves as #snapshot" do
     (subject + 1).should == 6
     (1 + subject).should == 6
   end
 
-  it "should be equal to other ExampleSingle" do
+  it "is equal to other ExampleSingle" do
     subject.should == ExampleSingle.new(5)
   end
 
-  it "should be equal to raw values" do
+  it "is equal to raw values" do
     subject.should == 5
     5.should == subject
   end
 
-  it "should work as hash keys" do
+  it "can be used as a hash key" do
     hash = {5 => 17}
 
     hash[subject].should == 17
   end
 
-  it "should be able to sort" do
+  it "is sortable" do
     [ExampleSingle.new(5), ExampleSingle.new(3)].sort.should == [3, 5]
   end
 end
@@ -128,38 +126,38 @@ end
 describe BinData::BasePrimitive, "after initialisation" do
   subject { ExampleSingle.new }
 
-  it "should not allow both :initial_value and :value" do
+  it "does not allow both :initial_value and :value" do
     params = {:initial_value => 1, :value => 2}
-    lambda { ExampleSingle.new(params) }.should raise_error(ArgumentError)
+    expect { ExampleSingle.new(params) }.to raise_error(ArgumentError)
   end
 
   it { should be_clear }
   its(:value) { should == 0 }
   its(:num_bytes) { should == 4 }
 
-  it "should have symmetric IO" do
+  it "has symmetric IO" do
     subject.assign(42)
     written = subject.to_binary_s
 
     ExampleSingle.read(written).should == 42
   end
 
-  it "should allowing setting and retrieving value" do
+  it "sets and retrieves values" do
     subject.value = 5
     subject.value.should == 5
   end
 
-  it "should not be clear after setting value" do
+  it "is not clear after setting value" do
     subject.assign(5)
     subject.should_not be_clear
   end
 
-  it "should not be clear after reading" do
+  it "is not clear after reading" do
     subject.read("\x11\x22\x33\x44")
     subject.should_not be_clear
   end
 
-  it "should return a snapshot" do
+  it "returns a snapshot" do
     subject.assign(5)
     subject.snapshot.should == 5
   end
@@ -170,17 +168,17 @@ describe BinData::BasePrimitive, "with :initial_value" do
 
   its(:value) { should == 5 }
 
-  it "should forget :initial_value after being set" do
+  it "forgets :initial_value after being set" do
     subject.assign(17)
     subject.should_not == 5
   end
 
-  it "should forget :initial_value after reading" do
+  it "forgets :initial_value after reading" do
     subject.read("\x11\x22\x33\x44")
     subject.should_not == 5
   end
 
-  it "should remember :initial_value after being cleared" do
+  it "remembers :initial_value after being cleared" do
     subject.assign(17)
     subject.clear
     subject.should == 5
@@ -194,18 +192,18 @@ describe BinData::BasePrimitive, "with :value" do
 
   let(:io) { ExampleSingle.io_with_value(56) }
 
-  it "should change during reading" do
+  it "changes during reading" do
     subject.read(io)
     subject.stub(:reading?).and_return(true)
     subject.should == 56
   end
 
-  it "should not change after reading" do
+  it "does not change after reading" do
     subject.read(io)
     subject.should == 5
   end
 
-  it "should not be able to change the value" do
+  it "is unaffected by assigning" do
     subject.assign(17)
     subject.should == 5
   end
@@ -215,26 +213,26 @@ describe BinData::BasePrimitive, "checking read value" do
   let(:io) { ExampleSingle.io_with_value(12) }
 
   context ":check_value is non boolean" do
-    it "should succeed when check_value and correct" do
+    it "succeeds when check_value is correct" do
       data = ExampleSingle.new(:check_value => 12)
-      lambda { data.read(io) }.should_not raise_error
+      expect { data.read(io) }.not_to raise_error
     end
 
-    it "should fail when check_value is incorrect" do
+    it "fails when check_value is incorrect" do
       data = ExampleSingle.new(:check_value => lambda { 99 })
-      lambda { data.read(io) }.should raise_error(BinData::ValidityError)
+      expect { data.read(io) }.to raise_error(BinData::ValidityError)
     end
   end
 
   context ":check_value is boolean" do
-    it "should succeed when check_value is true" do
+    it "succeeds when check_value is true" do
       data = ExampleSingle.new(:check_value => lambda { value < 20 })
-      lambda { data.read(io) }.should_not raise_error
+      expect { data.read(io) }.not_to raise_error
     end
 
-    it "should fail when check_value is false" do
+    it "fails when check_value is false" do
       data = ExampleSingle.new(:check_value => lambda { value > 20 })
-      lambda { data.read(io) }.should raise_error(BinData::ValidityError)
+      expect { data.read(io) }.to raise_error(BinData::ValidityError)
     end
   end
 end