bindata 1.2.2 → 1.3.1

data/spec/base_primitive_spec.rb

@@ -5,26 +5,24 @@ require File.expand_path(File.join(File.dirname(__FILE__), "example"))
 require 'bindata/base_primitive'
 require 'bindata/io'
 
-describe BinData::BasePrimitive, "when subclassing" do
+describe BinData::BasePrimitive, "all subclasses" do
   class SubClassOfBasePrimitive < BinData::BasePrimitive
     expose_methods_for_testing
   end
 
-  before(:each) do
-    @obj = SubClassOfBasePrimitive.new
-  end
+  subject { SubClassOfBasePrimitive.new }
 
   it "should raise errors on unimplemented methods" do
-    lambda { @obj.value_to_binary_string(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.read_and_return_value(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.sensible_default }.should raise_error(NotImplementedError)
+    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)
   end
 end
 
 describe BinData::BasePrimitive do
   it "should conform to rule 1 for returning a value" do
     data = ExampleSingle.new(:value => 5)
-    data.value.should == 5
+    data.should == 5
   end
 
   it "should conform to rule 2 for returning a value" do
@@ -32,224 +30,201 @@ describe BinData::BasePrimitive do
     data = ExampleSingle.new(:value => 5)
     data.read(io)
 
-    def data.reading?; true; end
-    data.value.should == 42
+    data.stub(:reading?).and_return(true)
+    data.should == 42
   end
 
   it "should conform to rule 3 for returning a value" do
     data = ExampleSingle.new(:initial_value => 5)
     data.should be_clear
-    data.value.should == 5
+    data.should == 5
   end
 
   it "should conform to rule 4 for returning a value" do
     data = ExampleSingle.new(:initial_value => 5)
-    data.value = 17
+    data.assign(17)
     data.should_not be_clear
-    data.value.should == 17
+    data.should == 17
   end
 
   it "should conform to rule 5 for returning a value" do
     data = ExampleSingle.new
     data.should be_clear
-    data.value.should == 0
+    data.should == 0
   end
 
   it "should conform to rule 6 for returning a value" do
     data = ExampleSingle.new
-    data.value = 8
+    data.assign(8)
     data.should_not be_clear
-    data.value.should == 8
+    data.should == 8
   end
 end
 
 describe ExampleSingle do
-  before(:each) do
-    @data = ExampleSingle.new
-    @data.value = 5
-  end
+  subject { ExampleSingle.new(5) }
 
   it "should fail when assigning nil values" do
-    lambda { @data.assign(nil) }.should raise_error(ArgumentError)
+    lambda { subject.assign(nil) }.should raise_error(ArgumentError)
   end
 
   it "should allowing setting and retrieving value" do
-    @data.value = 7
-    @data.value.should == 7
+    subject.assign(7)
+    subject.should == 7
   end
 
   it "should allowing setting and retrieving BinData::BasePrimitives" do
-    obj = ExampleSingle.new
-    obj.value = 7
-    @data.value = obj
-    @data.value.should == 7
+    subject.assign(ExampleSingle.new(7))
+    subject.should == 7
   end
 
   it "should respond to known methods" do
-    @data.should respond_to(:num_bytes)
+    subject.should respond_to(:num_bytes)
   end
 
   it "should respond to known methods in #snapshot" do
-    @data.should respond_to(:div)
+    subject.should respond_to(:div)
   end
 
   it "should not respond to unknown methods in self or #snapshot" do
-    @data.should_not respond_to(:does_not_exist)
+    subject.should_not respond_to(:does_not_exist)
   end
 
   it "should behave as #snapshot" do
-    (@data + 1).should == 6
-    (1 + @data).should == 6
+    (subject + 1).should == 6
+    (1 + subject).should == 6
   end
 
   it "should be equal to other ExampleSingle" do
-    other = ExampleSingle.new
-    other.value = 5
-    @data.should == other
+    subject.should == ExampleSingle.new(5)
   end
 
   it "should be equal to raw values" do
-    @data.should == 5
-    5.should == @data
+    subject.should == 5
+    5.should == subject
   end
 
   it "should work as hash keys" do
     hash = {5 => 17}
 
-    obj = ExampleSingle.new
-    obj.value = 5
+    hash[subject].should == 17
+  end
 
-    hash[obj].should == 17
+  it "should be able to sort" do
+    [ExampleSingle.new(5), ExampleSingle.new(3)].sort.should == [3, 5]
   end
 end
 
 describe BinData::BasePrimitive, "after initialisation" do
-  before(:each) do
-    @data = ExampleSingle.new
-  end
+  subject { ExampleSingle.new }
 
   it "should not allow both :initial_value and :value" do
     params = {:initial_value => 1, :value => 2}
     lambda { ExampleSingle.new(params) }.should raise_error(ArgumentError)
   end
 
-  it "should have a sensible value" do
-    @data.value.should == 0
-  end
+  it { should be_clear }
+  its(:value) { should == 0 }
+  its(:num_bytes) { should == 4 }
 
   it "should have symmetric IO" do
-    @data.value = 42
-    written = @data.to_binary_s
+    subject.assign(42)
+    written = subject.to_binary_s
 
     ExampleSingle.read(written).should == 42
   end
 
   it "should allowing setting and retrieving value" do
-    @data.value = 5
-    @data.value.should == 5
-  end
-
-  it "should be clear" do
-    @data.should be_clear
+    subject.value = 5
+    subject.value.should == 5
   end
 
   it "should not be clear after setting value" do
-    @data.value = 5
-    @data.should_not be_clear
+    subject.assign(5)
+    subject.should_not be_clear
   end
 
   it "should not be clear after reading" do
-    @data.read("\x11\x22\x33\x44")
-    @data.should_not be_clear
-  end
-
-  it "should return num_bytes" do
-    @data.num_bytes.should == 4
+    subject.read("\x11\x22\x33\x44")
+    subject.should_not be_clear
   end
 
   it "should return a snapshot" do
-    @data.value = 5
-    @data.snapshot.should == 5
+    subject.assign(5)
+    subject.snapshot.should == 5
   end
 end
 
 describe BinData::BasePrimitive, "with :initial_value" do
-  before(:each) do
-    @data = ExampleSingle.new(:initial_value => 5)
-  end
+  subject { ExampleSingle.new(:initial_value => 5) }
 
-  it "should return that initial value before reading or being set" do
-    @data.value.should == 5
-  end
+  its(:value) { should == 5 }
 
   it "should forget :initial_value after being set" do
-    @data.value = 17
-    @data.value.should_not == 5
+    subject.assign(17)
+    subject.should_not == 5
   end
 
   it "should forget :initial_value after reading" do
-    @data.read("\x11\x22\x33\x44")
-    @data.value.should_not == 5
+    subject.read("\x11\x22\x33\x44")
+    subject.should_not == 5
   end
 
   it "should remember :initial_value after being cleared" do
-    @data.value = 17
-    @data.clear
-    @data.value.should == 5
+    subject.assign(17)
+    subject.clear
+    subject.should == 5
   end
 end
 
 describe BinData::BasePrimitive, "with :value" do
-  before(:each) do
-    @data = ExampleSingle.new(:value => 5)
-  end
+  subject { ExampleSingle.new(:value => 5) }
 
-  it "should return that :value" do
-    @data.value.should == 5
-  end
+  its(:value) { should == 5 }
 
-  it "should change during reading" do
-    io = ExampleSingle.io_with_value(56)
-    @data.read(io)
+  let(:io) { ExampleSingle.io_with_value(56) }
 
-    def @data.reading?; true; end
-    @data.value.should == 56
+  it "should change during reading" do
+    subject.read(io)
+    subject.stub(:reading?).and_return(true)
+    subject.should == 56
   end
 
   it "should not change after reading" do
-    io = ExampleSingle.io_with_value(56)
-    @data.read(io)
-    @data.value.should == 5
+    subject.read(io)
+    subject.should == 5
   end
 
   it "should not be able to change the value" do
-    @data.value = 17
-    @data.value.should == 5
+    subject.assign(17)
+    subject.should == 5
   end
 end
 
-describe BinData::BasePrimitive, "with :check_value" do
-  before(:each) do
-    @io = ExampleSingle.io_with_value(34)
-  end
+describe BinData::BasePrimitive, "checking read value" do
+  let(:io) { ExampleSingle.io_with_value(12) }
 
-  it "should succeed when check_value is non boolean and correct" do
-    data = ExampleSingle.new(:check_value => 34)
-    lambda { data.read(@io) }.should_not raise_error
-  end
+  context ":check_value is non boolean" do
+    it "should succeed when check_value and correct" do
+      data = ExampleSingle.new(:check_value => 12)
+      lambda { data.read(io) }.should_not raise_error
+    end
 
-  it "should fail when check_value is non boolean and incorrect" do
-    data = ExampleSingle.new(:check_value => lambda { 123 * 5 })
-    lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
+    it "should fail when check_value is incorrect" do
+      data = ExampleSingle.new(:check_value => lambda { 99 })
+      lambda { data.read(io) }.should raise_error(BinData::ValidityError)
+    end
   end
 
-  it "should succeed when check_value is boolean and true" do
-    data = ExampleSingle.new(:check_value => lambda { (value % 2) == 0})
-    lambda { data.read(@io) }.should_not raise_error
-  end
+  context ":check_value is boolean" do
+    it "should succeed when check_value is true" do
+      data = ExampleSingle.new(:check_value => lambda { value < 20 })
+      lambda { data.read(io) }.should_not raise_error
+    end
 
-  it "should fail when check_value is boolean and false" do
-    data = ExampleSingle.new(:check_value => lambda { value > 100 })
-    lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
+    it "should fail when check_value is false" do
+      data = ExampleSingle.new(:check_value => lambda { value > 20 })
+      lambda { data.read(io) }.should raise_error(BinData::ValidityError)
+    end
   end
 end

data/spec/base_spec.rb

@@ -7,49 +7,32 @@ class BaseStub < BinData::Base
   # Override to avoid NotImplemented errors
   def clear; end
   def clear?; end
-  def assign(x); end
-  def snapshot; end
+  def assign(x); @data = x; end
+  def snapshot; @data; end
   def do_read(io) end
   def do_write(io) end
   def do_num_bytes; end
 end
 
-class MockBaseStub < BaseStub
-  attr_accessor :mock
-  def clear;           mock.clear; end
-  def clear?;          mock.clear?; end
-  def assign(x);       mock.assign(x); end
-  def snapshot;        mock.snapshot; end
-  def do_read(io)      mock.do_read(io); end
-  def do_write(io)     mock.do_write(io); end
-  def do_num_bytes;    mock.do_num_bytes; end
-end
-
-describe BinData::Base, "when subclassing" do
+describe BinData::Base, "all subclasses" do
   class SubClassOfBase < BinData::Base
     expose_methods_for_testing
   end
 
-  before(:each) do
-    @obj = SubClassOfBase.new
-  end
+  subject { SubClassOfBase.new }
 
   it "should raise errors on unimplemented methods" do
-    lambda { @obj.clear }.should raise_error(NotImplementedError)
-    lambda { @obj.clear? }.should raise_error(NotImplementedError)
-    lambda { @obj.assign(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.snapshot }.should raise_error(NotImplementedError)
-    lambda { @obj.do_read(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.do_write(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.do_num_bytes }.should raise_error(NotImplementedError)
+    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)
   end
 end
 
 describe BinData::Base, "with parameters" do
-  it "should raise error if parameter has nil value" do
-    lambda { BaseStub.new(:a => nil) }.should raise_error(ArgumentError)
-  end
-
   it "should raise error if parameter name is invalid" do
     lambda {
       class InvalidParameterNameBase < BinData::Base
@@ -58,10 +41,13 @@ describe BinData::Base, "with parameters" do
     }.should raise_error(NameError)
   end
 
-  it "should convert keys to symbols" do
-    obj = BaseStub.new('a' => 3)
-    obj.should have_parameter(:a)
-    obj.get_parameter(:a).should == 3
+  it "should raise error if parameter has nil value" do
+    lambda { BaseStub.new(:a => nil) }.should raise_error(ArgumentError)
+  end
+
+  it "should convert parameter keys to symbols" do
+    subject = BaseStub.new('a' => 3)
+    subject.should have_parameter(:a)
   end
 end
 
@@ -92,15 +78,13 @@ describe BinData::Base, "with default parameters" do
   end
 
   it "should use default parameters when not specified" do
-    obj = DefaultBase.new
-    obj.should have_parameter(:p1)
-    obj.eval_parameter(:p1).should == "a"
+    subject = DefaultBase.new
+    subject.eval_parameter(:p1).should == "a"
   end
 
   it "should be able to override default parameters" do
-    obj = DefaultBase.new(:p1 => "b")
-    obj.should have_parameter(:p1)
-    obj.eval_parameter(:p1).should == "b"
+    subject = DefaultBase.new(:p1 => "b")
+    subject.eval_parameter(:p1).should == "b"
   end
 end
 
@@ -127,8 +111,8 @@ end
 describe BinData::Base, "with multiple parameters" do
   class WithParamBase < BaseStub
     mandatory_parameter :p1
-    optional_parameter  :p2
-    default_parameter   :p3 => 3
+    default_parameter   :p2 => 2
+    optional_parameter  :p3
   end
 
   it "should identify internally accepted parameters" do
@@ -139,124 +123,110 @@ describe BinData::Base, "with multiple parameters" do
     accepted.should_not include(:xx)
   end
 
-  it "should evaluate parameters" do
-    params = {:p1 => 1, :p2 => 2, :p3 => 3, :p4 => lambda { 4 }}
-    obj = WithParamBase.new(params)
-    obj.eval_parameter(:p4).should == 4
-  end
+  context "examining parameters" do
+    subject {
+      params = {:p1 => 1, :p3 => :xx, :p4 => lambda { 4 }}
+      WithParamBase.new(params)
+    }
 
-  it "should return parameters" do
-    params = {:p1 => 1, :p2 => 2, :p3 => 3, :p4 => :a}
-    obj = WithParamBase.new(params)
-    obj.get_parameter(:p4).should == :a
-  end
-
-  it "should have parameters" do
-    params = {:p1 => 1, :p2 => 2, :p3 => 3, :p4 => 4}
-    obj = WithParamBase.new(params)
-    obj.should have_parameter(:p4)
-  end
+    it "should evaluate parameters" do
+      subject.eval_parameter(:p1).should == 1
+      subject.eval_parameter(:p2).should == 2
+      lambda { subject.eval_parameter(:p3) }.should raise_error(NoMethodError)
+      subject.eval_parameter(:p4).should == 4
+    end
 
-  it "should not allow parameters with nil values" do
-    lambda { WithParamBase.new(:p1 => 1, :p2 => nil) }.should raise_error(ArgumentError)
-  end
+    it "should get 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 be able to access without evaluating" do
-    obj = WithParamBase.new(:p1 => :asym, :p3 => lambda {1 + 2})
-    obj.get_parameter(:p1).should == :asym
-    obj.get_parameter(:p2).should be_nil
-    obj.get_parameter(:p3).should respond_to(:arity)
+    it "should have parameters" do
+      subject.should have_parameter(:p1)
+      subject.should have_parameter(:p2)
+      subject.should have_parameter(:p3)
+      subject.should have_parameter(:p4)
+    end
   end
 end
 
-describe BinData::Base, "with :check_offset" do
-  class TenByteOffsetBase < BaseStub
-    def initialize(params = {})
-      super({})
-      @child = BaseStub.new(params, self)
+describe BinData::Base, "when initializing" do
+  class BaseInit < BaseStub
+    class << self
+      attr_accessor :calls
+      def recorded_calls(&block)
+        self.calls = []
+        block.call
+        calls
+      end
     end
 
-    def do_read(io)
-      io.seekbytes(10)
-      @child.do_read(io)
+    def initialize_instance
+      self.class.calls << :initialize_instance
     end
-  end
-
-  before(:each) do
-    @io = StringIO.new("12345678901234567890")
-  end
-
-  it "should fail if offset is incorrect" do
-    @io.seek(2)
-    obj = TenByteOffsetBase.new(:check_offset => 8)
-    lambda { obj.read(@io) }.should raise_error(BinData::ValidityError)
-  end
 
-  it "should succeed if offset is correct" do
-    @io.seek(3)
-    obj = TenByteOffsetBase.new(:check_offset => 10)
-    lambda { obj.read(@io) }.should_not raise_error
+    def initialize_shared_instance
+      self.class.calls << :initialize_shared_instance
+    end
   end
 
-  it "should fail if :check_offset fails" do
-    @io.seek(4)
-    obj = TenByteOffsetBase.new(:check_offset => lambda { offset == 11 } )
-    lambda { obj.read(@io) }.should raise_error(BinData::ValidityError)
+  it "should call both #initialize_xxx methods when initializing" do
+    BaseInit.recorded_calls {
+      BaseInit.new
+    }.should == [:initialize_shared_instance, :initialize_instance]
   end
 
-  it "should succeed if :check_offset succeeds" do
-    @io.seek(5)
-    obj = TenByteOffsetBase.new(:check_offset => lambda { offset == 10 } )
-    lambda { obj.read(@io) }.should_not raise_error
-  end
-end
+  context "as a factory" do
+    subject { BaseInit.new(:check_offset => 1) }
 
-describe BinData::Base, "with :adjust_offset" do
-  class TenByteAdjustingOffsetBase < BaseStub
-    def initialize(params = {})
-      super({})
-      @child = BaseStub.new(params, self)
-    end
+    describe "#new" do
+      it "should call #initialize_instance" do
+        obj = subject
 
-    def do_read(io)
-      io.seekbytes(10)
-      @child.do_read(io)
-    end
-  end
+        BaseInit.recorded_calls {
+          obj.new
+        }.should == [:initialize_instance]
+      end
 
-  before(:each) do
-    @io = StringIO.new("12345678901234567890")
-  end
+      it "should copy parameters" do
+        obj = subject.new
+        obj.eval_parameter(:check_offset).should == 1
+      end
 
-  it "should be mutually exclusive with :check_offset" do
-    params = { :check_offset => 8, :adjust_offset => 8 }
-    lambda { TenByteAdjustingOffsetBase.new(params) }.should raise_error(ArgumentError)
-  end
+      it "should perform action for :check_offset" do
+        obj = subject.new
+        lambda {
+          obj.read("abc")
+        }.should raise_error(BinData::ValidityError)
+      end
 
-  it "should adjust if offset is incorrect" do
-    @io.seek(2)
-    obj = TenByteAdjustingOffsetBase.new(:adjust_offset => 13)
-    obj.read(@io)
-    @io.pos.should == (2 + 13)
-  end
+      it "should assign value" do
+        obj = subject.new(3)
+        obj.snapshot.should == 3
+      end
 
-  it "should succeed if offset is correct" do
-    @io.seek(3)
-    obj = TenByteAdjustingOffsetBase.new(:adjust_offset => 10)
-    lambda { obj.read(@io) }.should_not raise_error
-    @io.pos.should == (3 + 10)
+      it "should set parent" do
+        obj = subject.new(3, "p")
+        obj.parent.should == "p"
+      end
+    end
   end
+end
 
-  it "should fail if cannot adjust offset" do
-    @io.seek(3)
-    obj = TenByteAdjustingOffsetBase.new(:adjust_offset => -4)
-    lambda { obj.read(@io) }.should raise_error(BinData::ValidityError)
-  end
+describe BinData::Base, "as a factory" do
 end
 
 describe BinData::Base, "as black box" do
-  it "should return bindata_name" do
-    BaseStub.bindata_name.should == "base_stub"
+  context "class methods" do
+    it "should return bindata_name" do
+      BaseStub.bindata_name.should == "base_stub"
+    end
+
+    it "should instantiate self for ::read" do
+      BaseStub.read("").class.should == BaseStub
+    end
   end
 
   it "should access parent" do
@@ -265,47 +235,34 @@ describe BinData::Base, "as black box" do
     child.parent.should == parent
   end
 
-  it "should instantiate self for ::read" do
-    BaseStub.read("").class.should == BaseStub
-  end
+  subject { BaseStub.new }
 
   it "should return self for #read" do
-    obj = BaseStub.new
-    obj.read("").should == obj
+    subject.read("").should == subject
   end
 
   it "should return self for #write" do
-    obj = BaseStub.new
-    obj.write("").should == obj
+    subject.write("").should == subject
   end
 
   it "should forward #inspect to snapshot" do
-    class SnapshotBase < BaseStub
-      def snapshot; [1, 2, 3]; end
-    end
-    obj = SnapshotBase.new
-    obj.inspect.should == obj.snapshot.inspect
+    subject.stub(:snapshot).and_return([1, 2, 3])
+    subject.inspect.should == subject.snapshot.inspect
   end
 
   it "should forward #to_s to snapshot" do
-    class SnapshotBase < BaseStub
-      def snapshot; [1, 2, 3]; end
-    end
-    obj = SnapshotBase.new
-    obj.to_s.should == obj.snapshot.to_s
+    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
-    class SnapshotBase < BaseStub
-      def snapshot; [1, 2, 3]; end
-    end
-    obj = SnapshotBase.new
+    subject.stub(:snapshot).and_return([1, 2, 3])
     actual_io = StringIO.new
     expected_io = StringIO.new
 
     require 'pp'
-    PP.pp(obj, actual_io)
-    PP.pp(obj.snapshot, expected_io)
+    PP.pp(subject, actual_io)
+    PP.pp(subject.snapshot, expected_io)
 
     actual_io.value.should == expected_io.value
   end
@@ -315,37 +272,108 @@ describe BinData::Base, "as black box" do
       def do_write(io) io.writebytes("abc"); end
     end
 
-    obj = WriteToSBase.new
+    subject = WriteToSBase.new
     io = StringIO.new
-    obj.write(io)
-    io.value.should == obj.to_binary_s
+    subject.write(io)
+    io.value.should == subject.to_binary_s
   end
 end
 
 describe BinData::Base, "as white box" do
-  before(:each) do
-    @obj = MockBaseStub.new
-    @obj.mock = mock('mock')
-  end
+  subject { BaseStub.new }
 
   it "should forward read to do_read" do
-    @obj.mock.should_receive(:clear).ordered
-    @obj.mock.should_receive(:do_read).ordered
-    @obj.read(nil)
+    subject.should_receive(:clear).ordered
+    subject.should_receive(:do_read).ordered
+    subject.read(nil)
   end
 
   it "should forward write to do_write" do
-    @obj.mock.should_receive(:do_write)
-    @obj.write(nil)
+    subject.should_receive(:do_write)
+    subject.write(nil)
   end
 
   it "should forward num_bytes to do_num_bytes" do
-    @obj.mock.should_receive(:do_num_bytes).and_return(42)
-    @obj.num_bytes.should == 42
+    subject.should_receive(:do_num_bytes).and_return(42)
+    subject.num_bytes.should == 42
   end
 
   it "should round up fractional num_bytes" do
-    @obj.mock.should_receive(:do_num_bytes).and_return(42.1)
-    @obj.num_bytes.should == 43
+    subject.should_receive(:do_num_bytes).and_return(42.1)
+    subject.num_bytes.should == 43
+  end
+end
+
+describe BinData::Base, "checking offsets" do
+  class TenByteOffsetBase < BaseStub
+    def self.create(params)
+      obj = self.new
+      obj.initialize_child(params)
+      obj
+    end
+
+    def initialize_child(params)
+      @child = BaseStub.new(params, self)
+    end
+
+    def do_read(io)
+      io.seekbytes(10)
+      @child.do_read(io)
+    end
+  end
+
+  let(:io) { StringIO.new("12345678901234567890") }
+
+  context "with :check_offset" do
+    it "should fail if offset is incorrect" do
+      io.seek(2)
+      subject = TenByteOffsetBase.create(:check_offset => 8)
+      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+    end
+
+    it "should succeed if offset is correct" do
+      io.seek(3)
+      subject = TenByteOffsetBase.create(:check_offset => 10)
+      lambda { subject.read(io) }.should_not raise_error
+    end
+
+    it "should fail if :check_offset fails" do
+      io.seek(4)
+      subject = TenByteOffsetBase.create(:check_offset => lambda { offset == 11 } )
+      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+    end
+
+    it "should succeed if :check_offset succeeds" do
+      io.seek(5)
+      subject = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 } )
+      lambda { subject.read(io) }.should_not raise_error
+    end
+  end
+
+  context "with :adjust_offset" do
+    it "should be mutually exclusive with :check_offset" do
+      params = { :check_offset => 8, :adjust_offset => 8 }
+      lambda { TenByteOffsetBase.create(params) }.should raise_error(ArgumentError)
+    end
+
+    it "should adjust if offset is 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
+      io.seek(3)
+      subject = TenByteOffsetBase.create(:adjust_offset => 10)
+      lambda { subject.read(io) }.should_not raise_error
+      io.pos.should == (3 + 10)
+    end
+
+    it "should fail if cannot adjust offset" do
+      io.seek(4)
+      subject = TenByteOffsetBase.create(:adjust_offset => -5)
+      lambda { subject.read(io) }.should raise_error(BinData::ValidityError)
+    end
   end
 end