bindata 1.2.2 → 1.3.1

data/spec/lazy_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/lazy'
 
 # A mock data object with customizable fields.
-class MockDataObject
+class MockBinDataObject
   def initialize(methods = {}, params = {}, parent = nil)
     meta = class << self ; self; end
     methods.each do |k,v|
@@ -28,49 +28,49 @@ end
 LE = BinData::LazyEvaluator
 
 describe BinData::LazyEvaluator, "with no parents" do
-  before(:each) do
+  let(:obj) {
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    @obj = MockDataObject.new(methods, params)
-  end
+    MockBinDataObject.new(methods, params)
+  }
 
   it "should evaluate raw value when instantiated" do
-    le = LE.new(@obj)
+    le = LE.new(obj)
     le.lazy_eval(5).should == 5
   end
 
   it "should evaluate raw value" do
-    LE.eval(@obj, 5).should == 5
+    LE.eval(obj, 5).should == 5
   end
 
   it "should evaluate value" do
-    LE.eval(@obj, lambda { 5 }).should == 5
+    LE.eval(obj, lambda { 5 }).should == 5
   end
 
   it "should evaluate overrides" do
-    LE.eval(@obj, lambda { o1 }, :o1 => 'o1').should == 'o1'
+    LE.eval(obj, lambda { o1 }, :o1 => 'o1').should == 'o1'
   end
 
   it "should not resolve any unknown methods" do
-    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
-    lambda { LE.eval(@obj, lambda { m1 }) }.should raise_error(NameError)
-    lambda { LE.eval(@obj, lambda { p1 }) }.should raise_error(NameError)
+    lambda { LE.eval(obj, lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(obj, lambda { m1 }) }.should raise_error(NameError)
+    lambda { LE.eval(obj, lambda { p1 }) }.should raise_error(NameError)
   end
 
   it "should not have a parent" do
-    LE.eval(@obj, lambda { parent }).should be_nil
+    LE.eval(obj, lambda { parent }).should be_nil
   end
 
   it "should not resolve #index" do
-    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
+    lambda { LE.eval(obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
 describe BinData::LazyEvaluator, "with one parent" do
-  before(:each) do
+  let(:obj) {
     parent_methods = {:m1 => 'Pm1', :com => 'PmC', :mm => 3}
     parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
-    parent_obj = MockDataObject.new(parent_methods, parent_params)
+    parent_obj = MockBinDataObject.new(parent_methods, parent_params)
 
     def parent_obj.echo(a1, a2)
       [a1, a2]
@@ -78,59 +78,59 @@ describe BinData::LazyEvaluator, "with one parent" do
 
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    @obj = MockDataObject.new(methods, params, parent_obj)
-  end
+    MockBinDataObject.new(methods, params, parent_obj)
+  }
 
   it "should evaluate raw value" do
-    LE.eval(@obj, 5).should == 5
+    LE.eval(obj, 5).should == 5
   end
 
   it "should evaluate value" do
-    LE.eval(@obj, lambda { 5 }).should == 5
+    LE.eval(obj, lambda { 5 }).should == 5
   end
 
   it "should evaluate overrides before params" do
-    LE.eval(@obj, lambda { p1 }, :p1 => 'o1').should == 'o1'
+    LE.eval(obj, lambda { p1 }, :p1 => 'o1').should == 'o1'
   end
 
   it "should evaluate overrides before methods" do
-    LE.eval(@obj, lambda { m1 }, :m1 => 'o1').should == 'o1'
+    LE.eval(obj, lambda { m1 }, :m1 => 'o1').should == 'o1'
   end
 
   it "should not resolve any unknown methods" do
-    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(obj, lambda { unknown }) }.should raise_error(NameError)
   end
 
   it "should resolve parameters in the parent" do
-    LE.eval(@obj, lambda { p1 }).should == 'Pp1'
+    LE.eval(obj, lambda { p1 }).should == 'Pp1'
   end
 
   it "should resolve methods in the parent" do
-    LE.eval(@obj, lambda { m1 }).should == 'Pm1'
+    LE.eval(obj, lambda { m1 }).should == 'Pm1'
   end
 
   it "should invoke methods in the parent" do
-    LE.eval(@obj, lambda { echo(p1, m1) }).should == ['Pp1', 'Pm1']
+    LE.eval(obj, lambda { echo(p1, m1) }).should == ['Pp1', 'Pm1']
   end
 
   it "should resolve parameters in preference to methods in the parent" do
-    LE.eval(@obj, lambda { com }).should == 'PpC'
+    LE.eval(obj, lambda { com }).should == 'PpC'
   end
 
   it "should have a parent" do
-    LE.eval(@obj, lambda { parent }).should_not be_nil
+    LE.eval(obj, lambda { parent }).should_not be_nil
   end
 
   it "should not resolve #index" do
-    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
+    lambda { LE.eval(obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
 describe BinData::LazyEvaluator, "with nested parents" do
-  before(:each) do
+  let(:obj) {
     pparent_methods = {:m1 => 'PPm1', :m2 => 'PPm2', :com => 'PPmC'}
     pparent_params  = {:p1 => 'PPp1', :p2 => 'PPp2', :com => 'PPpC'}
-    pparent_obj = MockDataObject.new(pparent_methods, pparent_params)
+    pparent_obj = MockBinDataObject.new(pparent_methods, pparent_params)
 
     def pparent_obj.echo(arg)
       ["PP", arg]
@@ -142,7 +142,7 @@ describe BinData::LazyEvaluator, "with nested parents" do
 
     parent_methods = {:m1 => 'Pm1', :com => 'PmC', :sym1 => :m2, :sym2 => lambda { m2 }}
     parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
-    parent_obj = MockDataObject.new(parent_methods, parent_params, pparent_obj)
+    parent_obj = MockBinDataObject.new(parent_methods, parent_params, pparent_obj)
 
     def parent_obj.echo(arg)
       ["P", arg]
@@ -150,62 +150,62 @@ describe BinData::LazyEvaluator, "with nested parents" do
 
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    @obj = MockDataObject.new(methods, params, parent_obj)
-  end
+    MockBinDataObject.new(methods, params, parent_obj)
+  }
 
   it "should accept symbols as a shortcut to lambdas" do
-    LE.eval(@obj, :p1).should == 'Pp1'
-    LE.eval(@obj, :p2).should == 'PPp2'
-    LE.eval(@obj, :m1).should == 'Pm1'
-    LE.eval(@obj, :m2).should == 'PPm2'
+    LE.eval(obj, :p1).should == 'Pp1'
+    LE.eval(obj, :p2).should == 'PPp2'
+    LE.eval(obj, :m1).should == 'Pm1'
+    LE.eval(obj, :m2).should == 'PPm2'
   end
 
   it "should not resolve any unknown methods" do
-    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(obj, lambda { unknown }) }.should raise_error(NameError)
   end
 
   it "should resolve parameters in the parent" do
-    LE.eval(@obj, lambda { p1 }).should == 'Pp1'
+    LE.eval(obj, lambda { p1 }).should == 'Pp1'
   end
 
   it "should resolve methods in the parent" do
-    LE.eval(@obj, lambda { m1 }).should == 'Pm1'
+    LE.eval(obj, lambda { m1 }).should == 'Pm1'
   end
 
   it "should resolve parameters in the parent's parent" do
-    LE.eval(@obj, lambda { p2 }).should == 'PPp2'
+    LE.eval(obj, lambda { p2 }).should == 'PPp2'
   end
 
   it "should resolve methods in the parent's parent" do
-    LE.eval(@obj, lambda { m2 }).should == 'PPm2'
+    LE.eval(obj, lambda { m2 }).should == 'PPm2'
   end
 
   it "should invoke methods in the parent" do
-    LE.eval(@obj, lambda { echo(m1) }).should == ['P', 'Pm1']
+    LE.eval(obj, lambda { echo(m1) }).should == ['P', 'Pm1']
   end
 
   it "should invoke methods in the parent's parent" do
-    LE.eval(@obj, lambda { parent.echo(m1) }, { :m1 => 'o1'}).should == ['PP', 'o1']
+    LE.eval(obj, lambda { parent.echo(m1) }, { :m1 => 'o1'}).should == ['PP', 'o1']
   end
 
   it "should invoke methods in the parent's parent" do
-    LE.eval(@obj, lambda { echo2(m1) }).should == ['PP2', 'Pm1']
+    LE.eval(obj, lambda { echo2(m1) }).should == ['PP2', 'Pm1']
   end
 
   it "should resolve parameters in preference to methods in the parent" do
-    LE.eval(@obj, lambda { com }).should == 'PpC'
+    LE.eval(obj, lambda { com }).should == 'PpC'
   end
 
   it "should resolve methods in the parent explicitly" do
-    LE.eval(@obj, lambda { parent.m1 }).should == 'PPm1'
+    LE.eval(obj, lambda { parent.m1 }).should == 'PPm1'
   end
 
   it "should cascade lambdas " do
-    LE.eval(@obj, lambda { sym1 }).should == 'PPm2'
-    LE.eval(@obj, lambda { sym2 }).should == 'PPm2'
+    LE.eval(obj, lambda { sym1 }).should == 'PPm2'
+    LE.eval(obj, lambda { sym2 }).should == 'PPm2'
   end
 
   it "should not resolve #index" do
-    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
+    lambda { LE.eval(obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end

data/spec/primitive_spec.rb

@@ -3,18 +3,16 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata'
 
-describe BinData::Primitive, "when subclassing" do
+describe BinData::Primitive, "all subclasses" do
   class SubClassOfPrimitive < BinData::Primitive
     expose_methods_for_testing
   end
 
-  before(:each) do
-    @obj = SubClassOfPrimitive.new
-  end
+  subject { SubClassOfPrimitive.new }
 
   it "should raise errors on unimplemented methods" do
-    lambda { @obj.set(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.get }.should raise_error(NotImplementedError)
+    lambda { subject.set(nil) }.should raise_error(NotImplementedError)
+    lambda { subject.get }.should raise_error(NotImplementedError)
   end
 end
 
@@ -70,47 +68,50 @@ describe BinData::Primitive do
     def set(v); self.a = v; end
   end
 
-  before(:each) do
-    @obj = PrimitiveWithEndian.new
-  end
+  subject { PrimitiveWithEndian.new }
 
-  it "should support endian" do
-    @obj.value = 5
-    @obj.to_binary_s.should == "\x05\x00"
+  it "should assign value" do
+    subject.value = 5
+    subject.value.should == 5
   end
 
-  it "should set value" do
-    @obj.value = 5
-    @obj.to_binary_s.should == "\x05\x00"
+  it "should produce binary string" do
+    subject.assign(5)
+    subject.to_binary_s.should == "\x05\x00"
   end
 
   it "should read value" do
-    @obj.read("\x00\x01")
-    @obj.value.should == 0x100
+    subject.read("\x00\x01")
+    subject.should == 0x100
   end
 
   it "should accept standard parameters" do
-    obj = PrimitiveWithEndian.new(:initial_value => 2)
-    obj.to_binary_s.should == "\x02\x00"
+    subject = PrimitiveWithEndian.new(:initial_value => 2)
+    subject.to_binary_s.should == "\x02\x00"
   end
 
   it "should return num_bytes" do
-    @obj.num_bytes.should == 2
+    subject.num_bytes.should == 2
   end
 
   it "should raise error on missing methods" do
     lambda {
-      @obj.does_not_exist
+      subject.does_not_exist
     }.should raise_error(NoMethodError)
   end
 
   it "should use read value whilst reading" do
-    obj = PrimitiveWithEndian.new(:value => 2)
-    obj.read "\x05\x00"
-    obj.value.should == 2
+    subject = PrimitiveWithEndian.new(:value => 2)
+    subject.read "\x05\x00"
+    subject.should == 2
+
+    subject.stub(:reading?).and_return(true)
+    subject.should == 5
+  end
 
-    def obj.reading?; true; end
-    obj.value.should == 5
+  it "should behave as primitive" do
+    subject.assign(5)
+    (2 + subject).should == 7
   end
 end
 
@@ -122,8 +123,8 @@ describe BinData::Primitive, "requiring custom parameters" do
   end
 
   it "should pass parameters correctly" do
-    obj = PrimitiveWithCustom.new(:iv => 5)
-    obj.value.should == 5
+    subject = PrimitiveWithCustom.new(:iv => 5)
+    subject.should == 5
   end
 end
 
@@ -141,8 +142,8 @@ describe BinData::Primitive, "with custom mandatory parameters" do
   end
 
   it "should use mandatory parameter" do
-    obj = MandatoryPrimitive.new(:arg1 => 5)
-    obj.value.should == 5
+    subject = MandatoryPrimitive.new(:arg1 => 5)
+    subject.should == 5
   end
 end
 
@@ -160,13 +161,13 @@ describe BinData::Primitive, "with custom default parameters" do
   end
 
   it "should use default parameter" do
-    obj = DefaultPrimitive.new
-    obj.value.should == 5
+    subject = DefaultPrimitive.new
+    subject.should == 5
   end
 
   it "should be able to override default parameter" do
-    obj = DefaultPrimitive.new(:arg1 => 7)
-    obj.value.should == 7
+    subject = DefaultPrimitive.new(:arg1 => 7)
+    subject.should == 7
   end
 end
 
@@ -181,8 +182,7 @@ describe BinData::Primitive, "derived classes" do
   end
 
   it "should derive" do
-    a = ChildDerivedPrimitive.new
-    a.value = 7
+    a = ChildDerivedPrimitive.new(7)
     a.to_binary_s.should == "\000\007"
   end
 end

data/spec/record_spec.rb

@@ -53,7 +53,7 @@ describe BinData::Record, "when defining with errors" do
     lambda {
       class MalformedNameRecord < BinData::Record
         int8 :a
-        int8 45
+        int8 "45"
       end
     }.should raise_error_on_line(NameError, 3) { |err|
       err.message.should == "field '45' is an illegal fieldname in #{MalformedNameRecord}"
@@ -108,59 +108,56 @@ describe BinData::Record, "with anonymous fields" do
   class AnonymousRecord < BinData::Record
     int8 'a', :initial_value => 10
     int8 ''
+    int8 nil
     int8
     int8 :value => :a
   end
 
-  before(:each) do
-    @obj = AnonymousRecord.new
-  end
+  subject { AnonymousRecord.new }
 
   it "should only show non anonymous fields" do
-    @obj.field_names.should == ["a"]
+    subject.field_names.should == ["a"]
   end
 
   it "should not include anonymous fields in snapshot" do
-    @obj.a = 5
-    @obj.snapshot.should == {"a" => 5}
+    subject.a = 5
+    subject.snapshot.should == {"a" => 5}
   end
 
   it "should write anonymous fields" do
-    str = "\001\002\003\004"
-    @obj.read(str)
-    @obj.a.clear
-    @obj.to_binary_s.should == "\012\002\003\012"
+    str = "\001\002\003\004\005"
+    subject.read(str)
+    subject.a.clear
+    subject.to_binary_s.should == "\012\002\003\004\012"
   end
 end
 
 describe BinData::Record, "with hidden fields" do
   class HiddenRecord < BinData::Record
-    hide :b, 'c'
+    hide :b, :c
     int8 :a
     int8 'b', :initial_value => 10
     int8 :c
     int8 :d, :value => :b
   end
 
-  before(:each) do
-    @obj = HiddenRecord.new
-  end
+  subject { HiddenRecord.new }
 
   it "should only show fields that aren't hidden" do
-    @obj.field_names.should == ["a", "d"]
+    subject.field_names.should == ["a", "d"]
   end
 
   it "should be able to access hidden fields directly" do
-    @obj.b.should == 10
-    @obj.c = 15
-    @obj.c.should == 15
+    subject.b.should == 10
+    subject.c = 15
+    subject.c.should == 15
 
-    @obj.should respond_to(:b=)
+    subject.should respond_to(:b=)
   end
 
   it "should not include hidden fields in snapshot" do
-    @obj.b = 5
-    @obj.snapshot.should == {"a" => 0, "d" => 5}
+    subject.b = 5
+    subject.snapshot.should == {"a" => 0, "d" => 5}
   end
 end
 
@@ -170,16 +167,12 @@ describe BinData::Record, "with multiple fields" do
     int8 :b
   end
 
-  before(:each) do
-    @obj = MultiFieldRecord.new
-    @obj.a = 1
-    @obj.b = 2
-  end
+  subject { MultiFieldRecord.new(:a => 1, :b => 2) }
 
   it "should return num_bytes" do
-    @obj.a.num_bytes.should == 1
-    @obj.b.num_bytes.should == 1
-    @obj.num_bytes.should     == 2
+    subject.a.num_bytes.should == 1
+    subject.b.num_bytes.should == 1
+    subject.num_bytes.should     == 2
   end
 
   it "should identify accepted parameters" do
@@ -188,43 +181,43 @@ describe BinData::Record, "with multiple fields" do
   end
 
   it "should clear" do
-    @obj.a = 6
-    @obj.clear
-    @obj.should be_clear
+    subject.a = 6
+    subject.clear
+    subject.should be_clear
   end
 
   it "should clear individual elements" do
-    @obj.a = 6
-    @obj.b = 7
-    @obj.a.clear
-    @obj.a.should be_clear
-    @obj.b.should_not be_clear
+    subject.a = 6
+    subject.b = 7
+    subject.a.clear
+    subject.a.should be_clear
+    subject.b.should_not be_clear
   end
 
   it "should write ordered" do
-    @obj.to_binary_s.should == "\x01\x02"
+    subject.to_binary_s.should == "\x01\x02"
   end
 
   it "should read ordered" do
-    @obj.read("\x03\x04")
+    subject.read("\x03\x04")
 
-    @obj.a.should == 3
-    @obj.b.should == 4
+    subject.a.should == 3
+    subject.b.should == 4
   end
 
   it "should return a snapshot" do
-    snap = @obj.snapshot
+    snap = subject.snapshot
     snap.a.should == 1
     snap.b.should == 2
     snap.should == { "a" => 1, "b" => 2 }
   end
 
   it "should return field_names" do
-    @obj.field_names.should == ["a", "b"]
+    subject.field_names.should == ["a", "b"]
   end
   
   it "should fail on unknown method call" do
-    lambda { @obj.does_not_exist }.should raise_error(NoMethodError)
+    lambda { subject.does_not_exist }.should raise_error(NoMethodError)
   end
 end
 
@@ -242,39 +235,45 @@ describe BinData::Record, "with nested structs" do
     end
   end
 
-  before(:each) do
-    @obj = NestedStructRecord.new
-  end
+  subject { NestedStructRecord.new }
 
   it "should included nested field names" do
-    @obj.field_names.should == ["a", "b", "c"]
+    subject.field_names.should == ["a", "b", "c"]
   end
 
   it "should hide nested field names" do
-    @obj.b.field_names.should == ["x"]
+    subject.b.field_names.should == ["x"]
   end
 
   it "should access nested fields" do
-    @obj.a.should   == 6
-    @obj.b.w.should == 3
-    @obj.b.x.should == 6
-    @obj.c.y.should == 3
+    subject.a.should   == 6
+    subject.b.w.should == 3
+    subject.b.x.should == 6
+    subject.c.y.should == 3
   end
 
   it "should return correct offset" do
-    @obj.offset.should == 0
-    @obj.b.offset.should == 1
-    @obj.b.w.offset.should == 1
-    @obj.c.offset.should == 3
-    @obj.c.z.offset.should == 4
+    subject.offset.should == 0
+    subject.b.offset.should == 1
+    subject.b.w.offset.should == 1
+    subject.c.offset.should == 3
+    subject.c.z.offset.should == 4
   end
 
   it "should return correct rel_offset" do
-    @obj.rel_offset.should == 0
-    @obj.b.rel_offset.should == 1
-    @obj.b.w.rel_offset.should == 0
-    @obj.c.rel_offset.should == 3
-    @obj.c.z.rel_offset.should == 1
+    subject.rel_offset.should == 0
+    subject.b.rel_offset.should == 1
+    subject.b.w.rel_offset.should == 0
+    subject.c.rel_offset.should == 3
+    subject.c.z.rel_offset.should == 1
+  end
+
+  it "should assign nested fields" do
+    subject.assign(:a => 2, :b => {:w => 4})
+    subject.a.should   == 2
+    subject.b.w.should == 4
+    subject.b.x.should == 2
+    subject.c.y.should == 4
   end
 end
 
@@ -285,12 +284,10 @@ describe BinData::Record, "with nested array of primitives" do
     end
   end
 
-  before(:each) do
-    @obj = NestedPrimitiveArrayRecord.new
-  end
+  subject { NestedPrimitiveArrayRecord.new }
 
   it "should use block as :type" do
-    @obj.snapshot.should == {"a" => [0, 1, 2]}
+    subject.snapshot.should == {"a" => [0, 1, 2]}
   end
 end
 
@@ -302,31 +299,38 @@ describe BinData::Record, "with nested array of structs" do
     end
   end
 
-  before(:each) do
-    @obj = NestedStructArrayRecord.new
-  end
+  subject { NestedStructArrayRecord.new }
 
   it "should use block as struct for :type" do
-    @obj.a[0].b = 2
-    @obj.snapshot.should == {"a" => [{"b" => 2, "c" => 0}]}
+    subject.a[0].b = 2
+    subject.snapshot.should == {"a" => [{"b" => 2, "c" => 0}]}
   end
 end
 
-describe BinData::Record, "with nested choice without names" do
-  class NestedChoiceRecord < BinData::Record
+describe BinData::Record, "with nested choice with implied keys" do
+  class NestedChoiceWithImpliedKeysRecord < BinData::Record
     choice :a, :selection => 1 do
       uint8 :value => 1
       uint8 :value => 2
     end
   end
 
-  before(:each) do
-    @obj = NestedChoiceRecord.new
-  end
+  subject { NestedChoiceWithImpliedKeysRecord.new }
+
+  its(:a) { should == 2 }
+end
 
-  it "should select choices by index" do
-    @obj.a.should == 2
+describe BinData::Record, "with nested choice with explicit keys" do
+  class NestedChoiceWithKeysRecord < BinData::Record
+    choice :a, :selection => 5 do
+      uint8 3, :value => 1
+      uint8 5, :value => 2
+    end
   end
+
+  subject { NestedChoiceWithKeysRecord.new }
+
+  its(:a) { should == 2 }
 end
 
 describe BinData::Record, "with nested choice with names" do
@@ -337,13 +341,9 @@ describe BinData::Record, "with nested choice with names" do
     end
   end
 
-  before(:each) do
-    @obj = NestedChoiceWithNamesRecord.new
-  end
+  subject { NestedChoiceWithNamesRecord.new }
 
-  it "should select choices by name" do
-    @obj.a.should == 1
-  end
+  its(:a) { should == 1 }
 end
 
 describe BinData::Record, "with an endian defined" do
@@ -371,23 +371,21 @@ describe BinData::Record, "with an endian defined" do
     end
   end
 
-  before(:each) do
-    @obj = RecordWithEndian.new
-  end
+  subject { RecordWithEndian.new }
 
   it "should use correct endian" do
-    @obj.a = 1
-    @obj.b = 2.0
-    @obj.c[0] = 3
-    @obj.c[1] = 4
-    @obj.d = 5
-    @obj.e.f = 6
-    @obj.e.g = 7
-    @obj.h.i.j = 8
+    subject.a = 1
+    subject.b = 2.0
+    subject.c[0] = 3
+    subject.c[1] = 4
+    subject.d = 5
+    subject.e.f = 6
+    subject.e.g = 7
+    subject.h.i.j = 8
 
     expected = [1, 2.0, 3, 4, 5, 6, 7, 8].pack('veCCVvNn')
 
-    @obj.to_binary_s.should == expected
+    subject.to_binary_s.should == expected
   end
 end
 
@@ -400,30 +398,30 @@ describe BinData::Record, "defined recursively" do
   end
 
   it "should be able to be created" do
-    obj = RecursiveRecord.new
+    subject = RecursiveRecord.new
   end
 
   it "should read" do
     str = "\x00\x01\x01\x00\x02\x01\x00\x03\x00"
-    obj = RecursiveRecord.read(str)
-    obj.val.should == 1
-    obj.nxt.val.should == 2
-    obj.nxt.nxt.val.should == 3
+    subject = RecursiveRecord.read(str)
+    subject.val.should == 1
+    subject.nxt.val.should == 2
+    subject.nxt.nxt.val.should == 3
   end
 
   it "should be assignable on demand" do
-    obj = RecursiveRecord.new
-    obj.val = 13
-    obj.nxt.val = 14
-    obj.nxt.nxt.val = 15
+    subject = RecursiveRecord.new
+    subject.val = 13
+    subject.nxt.val = 14
+    subject.nxt.nxt.val = 15
   end
 
   it "should write" do
-    obj = RecursiveRecord.new
-    obj.val = 5
-    obj.nxt.val = 6
-    obj.nxt.nxt.val = 7
-    obj.to_binary_s.should == "\x00\x05\x01\x00\x06\x01\x00\x07\x00"
+    subject = RecursiveRecord.new
+    subject.val = 5
+    subject.nxt.val = 6
+    subject.nxt.nxt.val = 7
+    subject.to_binary_s.should == "\x00\x05\x01\x00\x06\x01\x00\x07\x00"
   end
 end
 
@@ -439,8 +437,8 @@ describe BinData::Record, "with custom mandatory parameters" do
   end
 
   it "should use mandatory parameter" do
-    obj = MandatoryRecord.new(:arg1 => 5)
-    obj.a.should == 5
+    subject = MandatoryRecord.new(:arg1 => 5)
+    subject.a.should == 5
   end
 end
 
@@ -449,6 +447,7 @@ describe BinData::Record, "with custom default parameters" do
     default_parameter :arg1 => 5
 
     uint8 :a, :value => :arg1
+    uint8 :b
   end
 
   it "should not raise error if default parameter is not supplied" do
@@ -456,13 +455,24 @@ describe BinData::Record, "with custom default parameters" do
   end
 
   it "should use default parameter" do
-    obj = DefaultRecord.new
-    obj.a.should == 5
+    subject = DefaultRecord.new
+    subject.a.should == 5
   end
 
   it "should be able to override default parameter" do
-    obj = DefaultRecord.new(:arg1 => 7)
-    obj.a.should == 7
+    subject = DefaultRecord.new(:arg1 => 7)
+    subject.a.should == 7
+  end
+
+  it "should accept values" do
+    subject = DefaultRecord.new(:b => 2)
+    subject.b.should == 2
+  end
+
+  it "should accept values and parameters" do
+    subject = DefaultRecord.new({:b => 2}, :arg1 => 3)
+    subject.a.should == 3
+    subject.b.should == 2
   end
 end
 
@@ -473,25 +483,15 @@ describe BinData::Record, "with :onlyif" do
     uint8 :c, :initial_value => 7, :onlyif => lambda { a != 3 }
   end
 
-  before(:each) do
-    @obj = OnlyIfRecord.new
-  end
+  subject { OnlyIfRecord.new }
 
-  it "should have correct num_bytes" do
-    @obj.num_bytes.should == 2
-  end
-
-  it "should have expected snapshot" do
-    @obj.snapshot.should == {"a" => 3, "b" => 5}
-  end
+  its(:num_bytes) { should == 2 }
+  its(:snapshot) { should == {"a" => 3, "b" => 5} }
+  its(:to_binary_s) { should == "\x03\x05" }
 
   it "should read as expected" do
-    @obj.read("\x01\x02")
-    @obj.snapshot.should == {"a" => 1, "c" => 2}
-  end
-
-  it "should write as expected" do
-    @obj.to_binary_s.should == "\x03\x05"
+    subject.read("\x01\x02")
+    subject.snapshot.should == {"a" => 1, "c" => 2}
   end
 end