spec/base_spec.rb in bindata-0.11.1 vs spec/base_spec.rb in bindata-1.0.0

@@ -8,11 +8,11 @@
   def clear; end
   def clear?; end
   def _do_read(io) end
   def _done_read; end
   def _do_write(io) end
-  def _do_num_bytes(x) end
+  def _do_num_bytes; end
   def _assign(x); end
   def _snapshot; end
 
   expose_methods_for_testing
 end
@@ -22,11 +22,11 @@
   def clear;           mock.clear; end
   def clear?;          mock.clear?; end
   def _do_read(io)     mock._do_read(io); end
   def _done_read;      mock._done_read; end
   def _do_write(io)    mock._do_write(io); end
-  def _do_num_bytes(x) mock._do_num_bytes(x) end
+  def _do_num_bytes;   mock._do_num_bytes; end
   def _assign(x);      mock._assign(x); end
   def _snapshot;       mock._snapshot; end
 end
 
 describe BinData::Base, "when subclassing" do
@@ -40,16 +40,14 @@
 
   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.debug_name_of(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.offset_of(nil) }.should raise_error(NotImplementedError)
     lambda { @obj._do_read(nil) }.should raise_error(NotImplementedError)
     lambda { @obj._done_read }.should raise_error(NotImplementedError)
     lambda { @obj._do_write(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj._do_num_bytes(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj._do_num_bytes }.should raise_error(NotImplementedError)
     lambda { @obj._snapshot }.should raise_error(NotImplementedError)
   end
 end
 
 describe BinData::Base, "with parameters" do
@@ -166,31 +164,10 @@
 
   it "should not allow parameters with nil values" do
     lambda { WithParamBase.new(:p1 => 1, :p2 => nil) }.should raise_error(ArgumentError)
   end
 
-=begin
-# TODO: how should we evaluate internal parameters? think about this
-  it "should only recall mandatory, default and optional parameters" do
-    obj = WithParamBase.new(:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5)
-    obj.should     have_param(:p1)
-    obj.should_not have_param(:p2)
-    obj.should     have_param(:p3)
-    obj.should_not have_param(:p4)
-    obj.should_not have_param(:p5)
-  end
-
-  it "should evaluate mandatory, default and optional parameters" do
-    obj = WithParamBase.new(:p1 => 1, :p3 => lambda {1 + 2}, :p4 => 4, :p5 => 5)
-    obj.eval_parameter(:p1).should == 1
-    obj.eval_parameter(:p2).should be_nil
-    obj.eval_parameter(:p3).should == 3
-    obj.eval_parameter(:p4).should be_nil
-    obj.eval_parameter(:p5).should be_nil
-  end
-=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)
@@ -205,11 +182,11 @@
       super(io)
     end
   end
 
   before(:each) do
-    @io = StringIO.new("12345678901234567890")
+    @io = BinData::IO.create_string_io("12345678901234567890")
   end
 
   it "should fail if offset is incorrect" do
     @io.seek(2)
     obj = TenByteOffsetBase.new(:check_offset => 8)
@@ -243,11 +220,11 @@
       super(io)
     end
   end
 
   before(:each) do
-    @io = StringIO.new("12345678901234567890")
+    @io = BinData::IO.create_string_io("12345678901234567890")
   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)
@@ -315,10 +292,10 @@
     class WriteToSBase < BaseStub
       def _do_write(io) io.writebytes("abc"); end
     end
 
     obj = WriteToSBase.new
-    io = StringIO.new
+    io = BinData::IO.create_string_io
     obj.write(io)
     io.rewind
     written = io.read
     obj.to_binary_s.should == written
   end