bindata 1.4.3 → 1.4.4

data/spec/struct_spec.rb

@@ -4,40 +4,40 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata'
 
 describe BinData::Struct, "when initializing" do
-  it "should fail on non registered types" do
+  it "fails on non registered types" do
     params = {:fields => [[:non_registered_type, :a]]}
-    lambda {
+    expect {
       BinData::Struct.new(params)
-    }.should raise_error(BinData::UnRegisteredTypeError)
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should fail on duplicate names" do
+  it "fails on duplicate names" do
     params = {:fields => [[:int8, :a], [:int8, :b], [:int8, :a]]}
-    lambda {
+    expect {
       BinData::Struct.new(params)
-    }.should raise_error(NameError)
+    }.to raise_error(NameError)
   end
 
-  it "should fail on reserved names" do
+  it "fails on reserved names" do
     # note that #invert is from Hash.instance_methods
     params = {:fields => [[:int8, :a], [:int8, :invert]]}
-    lambda {
+    expect {
       BinData::Struct.new(params)
-    }.should raise_error(NameError)
+    }.to raise_error(NameError)
   end
 
-  it "should fail when field name shadows an existing method" do
+  it "fails when field name shadows an existing method" do
     params = {:fields => [[:int8, :object_id]]}
-    lambda {
+    expect {
       BinData::Struct.new(params)
-    }.should raise_error(NameError)
+    }.to raise_error(NameError)
   end
 
-  it "should fail on unknown endian" do
+  it "fails on unknown endian" do
     params = {:endian => 'bad value', :fields => []}
-    lambda {
+    expect {
       BinData::Struct.new(params)
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 end
 
@@ -51,16 +51,16 @@ describe BinData::Struct, "with anonymous fields" do
     BinData::Struct.new(params)
   }
 
-  it "should only show non anonymous fields" do
+  it "only shows non anonymous fields" do
     subject.field_names.should == ["a"]
   end
 
-  it "should not include anonymous fields in snapshot" do
+  it "does not include anonymous fields in snapshot" do
     subject.a = 5
     subject.snapshot.should == {"a" => 5}
   end
 
-  it "should write anonymous fields" do
+  it "writes anonymous fields" do
     subject.read("\001\002\003")
     subject.a.clear
     subject.to_binary_s.should == "\005\002\005"
@@ -78,11 +78,11 @@ describe BinData::Struct, "with hidden fields" do
     BinData::Struct.new(params)
   }
 
-  it "should only show fields that aren't hidden" do
+  it "only shows fields that aren't hidden" do
     subject.field_names.should == ["a", "d"]
   end
 
-  it "should be able to access hidden fields directly" do
+  it "accesses hidden fields directly" do
     subject.b.should == 5
     subject.c = 15
     subject.c.should == 15
@@ -90,12 +90,12 @@ describe BinData::Struct, "with hidden fields" do
     subject.should respond_to(:b=)
   end
 
-  it "should not include hidden fields in snapshot" do
+  it "does not include hidden fields in snapshot" do
     subject.b = 7
     subject.snapshot.should == {"a" => 0, "d" => 7}
   end
 
-  it "should detect hidden fields with has_key?" do
+  it "detects hidden fields with has_key?" do
     subject.should have_key("b")
   end
 end
@@ -107,25 +107,25 @@ describe BinData::Struct, "with multiple fields" do
   its(:field_names) { should == ["a", "b"] }
   its(:to_binary_s) { should == "\x01\x02" }
 
-  it "should return num_bytes" do
+  it "returns num_bytes" do
     subject.a.num_bytes.should == 1
     subject.b.num_bytes.should == 1
     subject.num_bytes.should   == 2
   end
 
-  it "should identify accepted parameters" do
+  it "identifies accepted parameters" do
     BinData::Struct.accepted_parameters.all.should include(:fields)
     BinData::Struct.accepted_parameters.all.should include(:hide)
     BinData::Struct.accepted_parameters.all.should include(:endian)
   end
 
-  it "should clear" do
+  it "clears" do
     subject.a = 6
     subject.clear
     subject.should be_clear
   end
 
-  it "should clear individual elements" do
+  it "clears individual elements" do
     subject.a = 6
     subject.b = 7
     subject.a.clear
@@ -133,51 +133,51 @@ describe BinData::Struct, "with multiple fields" do
     subject.b.should_not be_clear
   end
 
-  it "should read elements dynamically" do
+  it "reads elements dynamically" do
     subject[:a].should == 1
   end
 
-  it "should write elements dynamically" do
+  it "writes elements dynamically" do
     subject[:a] = 2
     subject.a.should == 2
   end
 
-  it "should implement has_key?" do
+  it "implements has_key?" do
     subject.should have_key("a")
   end
 
-  it "should read ordered" do
+  it "reads ordered" do
     subject.read("\x03\x04")
 
     subject.a.should == 3
     subject.b.should == 4
   end
 
-  it "should return a snapshot" do
+  it "returns a snapshot" do
     snap = subject.snapshot
     snap.a.should == 1
     snap.b.should == 2
     snap.should == { "a" => 1, "b" => 2 }
   end
 
-  it "should assign from partial hash" do
+  it "assigns from partial hash" do
     subject.assign("a" => 3)
     subject.a.should == 3
     subject.b.should == 0
   end
 
-  it "should assign from hash" do
+  it "assigns from hash" do
     subject.assign("a" => 3, "b" => 4)
     subject.a.should == 3
     subject.b.should == 4
   end
 
-  it "should assign from nil" do
+  it "assigns from nil" do
     subject.assign(nil)
     subject.should be_clear
   end
 
-  it "should assign from Struct" do
+  it "assigns from Struct" do
     src = BinData::Struct.new(params)
     src.a = 3
     src.b = 4
@@ -187,7 +187,7 @@ describe BinData::Struct, "with multiple fields" do
     subject.b.should == 4
   end
 
-  it "should assign from snapshot" do
+  it "assigns from snapshot" do
     src = BinData::Struct.new(params)
     src.a = 3
     src.b = 4
@@ -197,22 +197,22 @@ describe BinData::Struct, "with multiple fields" do
     subject.b.should == 4
   end
 
-  it "should fail on unknown method call" do
-    lambda { subject.does_not_exist }.should raise_error(NoMethodError)
+  it "fails on unknown method call" do
+    expect { subject.does_not_exist }.to raise_error(NoMethodError)
   end
 
   context "#snapshot" do
-    it "should have ordered #keys" do
+    it "has ordered #keys" do
       subject.snapshot.keys.should == ["a", "b"]
     end
 
-    it "should have ordered #each" do
+    it "has ordered #each" do
       keys = []
       subject.snapshot.each { |el| keys << el[0] }
       keys.should == ["a", "b"]
     end
 
-    it "should have ordered #each_pair" do
+    it "has ordered #each_pair" do
       keys = []
       subject.snapshot.each_pair { |k, v| keys << k }
       keys.should == ["a", "b"]
@@ -237,13 +237,13 @@ describe BinData::Struct, "with nested structs" do
 
   its(:field_names) { should == ["a", "b", "c"] }
 
-  it "should return num_bytes" do
+  it "returns num_bytes" do
     subject.b.num_bytes.should == 2
     subject.c.num_bytes.should == 2
     subject.num_bytes.should == 5
   end
 
-  it "should access nested fields" do
+  it "accesses nested fields" do
     subject.a.should   == 6
     subject.b.w.should == 3
     subject.b.x.should == 6
@@ -251,7 +251,7 @@ describe BinData::Struct, "with nested structs" do
     subject.c.z.should == 0
   end
 
-  it "should return correct offset" do
+  it "returns correct offset" do
     subject.b.offset.should == 1
     subject.b.w.offset.should == 1
     subject.c.offset.should == 3
@@ -279,7 +279,7 @@ describe BinData::Struct, "with an endian defined" do
                                            {:fields => [[:uint16, :j]]}]]}]])
   }
 
-  it "should use correct endian" do
+  it "uses correct endian" do
     subject.a = 1
     subject.b = 2.0
     subject.c[0] = 3
@@ -304,7 +304,7 @@ describe BinData::Struct, "with bit fields" do
   its(:num_bytes) { should == 3 }
   its(:to_binary_s) { should == [0b0000_0101, 3, 1].pack("C*") }
 
-  it "should read" do
+  it "reads" do
     str = [0b0000_0110, 5, 0].pack("C*")
     subject.read(str)
     subject.a.should == 0
@@ -313,7 +313,7 @@ describe BinData::Struct, "with bit fields" do
     subject.d.should == 0
   end
 
-  it "should have correct offsets" do
+  it "has correct offsets" do
     subject.a.offset.should == 0
     subject.b.offset.should == 0
     subject.c.offset.should == 1
@@ -322,7 +322,7 @@ describe BinData::Struct, "with bit fields" do
 end
 
 describe BinData::Struct, "with nested endian" do
-  it "should use correct endian" do
+  it "uses correct endian" do
     nested_params = { :endian => :little,
                       :fields => [[:int16, :b], [:int16, :c]] }
     params = { :endian => :big, 

data/spec/system_spec.rb

@@ -9,27 +9,27 @@ describe "lambdas with index" do
     uint8 :a, :value => lambda { index * 10 }
   end
 
-  it "should use index of containing array" do
+  it "uses index of containing array" do
     arr = BinData::Array.new(:type =>
                                [:uint8, { :value => lambda { index * 10 } }],
                              :initial_length => 3)
     arr.snapshot.should == [0, 10, 20]
   end
 
-  it "should use index of nearest containing array" do
+  it "uses index of nearest containing array" do
     arr = BinData::Array.new(:type => :nested_lambda_with_index,
                              :initial_length => 3)
     arr.snapshot.should == [{"a" => 0}, {"a" => 10}, {"a" => 20}]
   end
 
-  it "should fail if there is no containing array" do
+  it "fails if there is no containing array" do
     subject = NestedLambdaWithIndex.new
-    lambda { subject.a.to_s }.should raise_error(NoMethodError)
+    expect { subject.a.to_s }.to raise_error(NoMethodError)
   end
 end
 
 describe "lambdas with parent" do
-  it "should access immediate parent when no parent is specified" do
+  it "accesses immediate parent when no parent is specified" do
     class NestedLambdaWithoutParent < BinData::Record
       int8 :a, :value => 5
       int8 :b, :value => lambda { a }
@@ -44,7 +44,7 @@ describe "lambdas with parent" do
     subject.x.b.should == 5
   end
 
-  it "should access parent's parent when parent is specified" do
+  it "accesses parent's parent when parent is specified" do
     class NestedLambdaWithParent < BinData::Record
       int8 :a, :value => 5
       int8 :b, :value => lambda { parent.a }
@@ -73,35 +73,36 @@ describe BinData::Record, "with choice field" do
   end
 
   class RecordWithNestedChoiceField < BinData::Record
+    uint8  :sel, :value => 0
     choice :x, :selection => 0 do
-      choice :selection => 0 do
+      choice :selection => :sel do
         tuple_record
       end
     end
   end
 
-  it "should treat choice object transparently " do
+  it "treats choice object transparently " do
     subject = RecordWithChoiceField.new
 
     subject.x.a.should == 3
   end
 
-  it "should treat nested choice object transparently " do
+  it "treats nested choice object transparently " do
     subject = RecordWithNestedChoiceField.new
 
     subject.x.a.should == 3
   end
 
-  it "should have correct offset" do
+  it "has correct offset" do
     subject = RecordWithNestedChoiceField.new
-    subject.x.b.offset.should == 1
+    subject.x.b.offset.should == 2
   end
 end
 
 describe BinData::Array, "of bits" do
   let(:data) { BinData::Array.new(:type => :bit1, :initial_length => 15) }
 
-  it "should read" do
+  it "reads" do
     str = [0b0001_0100, 0b1000_1000].pack("CC")
     data.read(str)
     data[0].should  == 0
@@ -121,16 +122,16 @@ describe BinData::Array, "of bits" do
     data[14].should == 0
   end
 
-  it "should write" do
+  it "writes" do
     data[3] = 1
     data.to_binary_s.should == [0b0001_0000, 0b0000_0000].pack("CC")
   end
 
-  it "should return num_bytes" do
+  it "returns num_bytes" do
     data.num_bytes.should == 2
   end
 
-  it "should have correct offset" do
+  it "has correct offset" do
     data[7].offset.should == 0
     data[8].offset.should == 1
   end
@@ -170,11 +171,11 @@ describe BinData::Record, "containing bitfields" do
 
   subject { BitfieldRecord.new }
 
-  it "should have correct num_bytes" do
+  it "has correct num_bytes" do
     subject.num_bytes.should == 5
   end
 
-  it "should read across bitfield boundaries" do
+  it "reads across bitfield boundaries" do
     subject.read [0b0111_0010, 0b0110_0101, 0b0010_1010, 0b1000_0101, 0b1000_0000].pack("CCCCC")
 
     subject.a.w.should == 7
@@ -184,7 +185,7 @@ describe BinData::Record, "containing bitfields" do
     subject.e.should == 11
   end
 
-  it "should write across bitfield boundaries" do
+  it "writes across bitfield boundaries" do
     subject.a.w = 3
     subject.b[2] = 1
     subject.b[5] = 1
@@ -196,28 +197,28 @@ describe BinData::Record, "containing bitfields" do
 end
 
 describe "Objects with debug_name" do
-  it "should have default name of obj" do
+  it "haves default name of obj" do
     el = ExampleSingle.new
     el.debug_name.should == "obj"
   end
 
-  it "should include array index" do
+  it "includes array index" do
     arr = BinData::Array.new(:type => :example_single, :initial_length => 2)
     arr[2].debug_name.should == "obj[2]"
   end
 
-  it "should include field name" do
+  it "includes field name" do
     s = BinData::Struct.new(:fields => [[:example_single, :a]])
     s.a.debug_name.should == "obj.a"
   end
 
-  it "should delegate to choice" do
+  it "delegates to choice" do
     choice_params = {:choices => [:example_single], :selection => 0}
     s = BinData::Struct.new(:fields => [[:choice, :a, choice_params]])
     s.a.debug_name.should == "obj.a"
   end
 
-  it "should nest" do
+  it "nests" do
     nested_struct_params = {:fields => [[:example_single, :c]]}
     struct_params = {:fields => [[:struct, :b, nested_struct_params]]}
     s = BinData::Struct.new(:fields => [[:struct, :a, struct_params]])
@@ -236,7 +237,7 @@ describe "Tracing"  do
     io.value.should == expected
   end
 
-  it "should trace custom single values" do
+  it "traces custom single values" do
     class DebugNamePrimitive < BinData::Primitive
       int8 :ex
       def get;     self.ex; end
@@ -251,7 +252,7 @@ describe "Tracing"  do
     io.value.should == ["obj-internal-.ex => 1\n", "obj => 1\n"].join("")
   end
 
-  it "should trace choice selection" do
+  it "traces choice selection" do
     subject = BinData::Choice.new(:choices => [:int8, :int16be], :selection => 0)
 
     io = StringIO.new
@@ -260,7 +261,7 @@ describe "Tracing"  do
     io.value.should == ["obj-selection- => 0\n", "obj => 1\n"].join("")
   end
 
-  it "should trim long trace values" do
+  it "trims long trace values" do
     subject = BinData::String.new(:read_length => 40)
 
     io = StringIO.new
@@ -278,16 +279,16 @@ describe "Forward referencing with Primitive" do
 
   subject { FRPrimitive.new }
 
-  it "should initialise" do
+  it "initialises" do
     subject.snapshot.should == {"len" => 0, "data" => ""}
   end
 
-  it "should read" do
+  it "reads" do
     subject.read("\x04test")
     subject.snapshot.should == {"len" => 4, "data" => "test"}
   end
 
-  it "should set value" do
+  it "sets value" do
     subject.data = "hello"
     subject.snapshot.should == {"len" => 5, "data" => "hello"}
   end
@@ -301,16 +302,16 @@ describe "Forward referencing with Array" do
 
   subject { FRArray.new }
 
-  it "should initialise" do
+  it "initialises" do
     subject.snapshot.should == {"len" => 0, "data" => []}
   end
 
-  it "should read" do
+  it "reads" do
     subject.read("\x04\x01\x02\x03\x04")
     subject.snapshot.should == {"len" => 4, "data" => [1, 2, 3, 4]}
   end
 
-  it "should set value" do
+  it "sets value" do
     subject.data = [1, 2, 3]
     subject.snapshot.should == {"len" => 3, "data" => [1, 2, 3]}
   end
@@ -325,7 +326,7 @@ describe "Evaluating custom parameters" do
     uint8 :c, :custom => :b
   end
 
-  it "should recursively evaluate parameter" do
+  it "recursively evaluates parameter" do
     subject = CustomParameterRecord.new(:zz => 5)
     subject.c.eval_parameter(:custom).should == 5
   end
@@ -336,7 +337,7 @@ describe BinData::Record, "with custom sized integers" do
     int40be :a
   end
 
-  it "should read as expected" do
+  it "reads as expected" do
     str = "\x00\x00\x00\x00\x05"
     CustomIntRecord.read(str).should == {"a" => 5}
   end
@@ -350,7 +351,7 @@ describe BinData::Record, "with choice field" do
     end
   end
 
-  it "should assign" do
+  it "assigns" do
     subject = BinData::Array.new(:type => :choice_field_record)
     obj = ChoiceFieldRecord.new(:a => 1, :b => {:v => 3})
     subject.assign([obj])
@@ -368,11 +369,11 @@ describe BinData::Primitive, "representing a string" do
 
   subject { PascalStringPrimitive.new("testing") }
 
-  it "should compare to regexp" do
+  it "compares to regexp" do
     (subject =~ /es/).should == 1
   end
 
-  it "should compare to regexp" do
+  it "compares to regexp" do
     (/es/ =~ subject).should == 1
   end
 end