bindata 0.9.1 → 0.9.2

data/spec/array_spec.rb

@@ -30,18 +30,10 @@ describe BinData::Array, "with no elements" do
     @data = BinData::Array.new(:type => :int8)
   end
 
-  it "should not have any field_names" do
-    BinData::Array.all_possible_field_names(nil).should be_empty
-  end
-
   it "should not be a single_value" do
     @data.should_not be_single_value
   end
 
-  it "should have no field names" do
-    @data.field_names.should be_empty
-  end
-
   it "should return correct length" do
     @data.length.should be_zero
   end
@@ -79,18 +71,10 @@ describe BinData::Array, "with several elements" do
     @data = BinData::Array.new(:type => type, :initial_length => 5)
   end
 
-  it "should not have any field_names" do
-    BinData::Array.all_possible_field_names(nil).should be_empty
-  end
-
   it "should not be a single_value" do
     @data.should_not be_single_value
   end
 
-  it "should have no field names" do
-    @data.field_names.should be_empty
-  end
-
   it "should return a correct snapshot" do
     @data.snapshot.should == [1, 2, 3, 4, 5]
   end
@@ -134,10 +118,6 @@ describe BinData::Array, "with several elements" do
     @data.num_bytes(0).should == 2
   end
 
-  it "should have no field_names" do
-    @data.field_names.should be_empty
-  end
-
   it "should be able to directly access elements" do
     @data[1] = 8
     @data[1].should == 8
@@ -155,6 +135,12 @@ describe BinData::Array, "with several elements" do
     @data.select { |x| (x % 2) == 0 }.should == [2, 4]
   end
 
+  it "should automatically extend" do
+    @data[9] = 3
+    @data[8].should == 9
+    @data.length.should == 10
+  end
+
   it "should clear" do
     @data[1] = 8
     @data.clear
@@ -167,6 +153,11 @@ describe BinData::Array, "with several elements" do
     @data[1].should == 2
   end
 
+  it "should clear a single element out of range without extending" do
+    @data.clear(9)
+    @data.length.should == 5
+  end
+
   it "should be clear upon creation" do
     @data.clear?.should be_true
   end
@@ -183,6 +174,11 @@ describe BinData::Array, "with several elements" do
     @data.clear?(1).should be_false
   end
 
+  it "should test clear status of out of range elements without extending" do
+    @data.clear?(9).should be_true
+    @data.length.should == 5
+  end
+
   it "should read and write correctly" do
     io = StringIO.new
     @data[1] = 8

data/spec/base_spec.rb

@@ -5,13 +5,13 @@ require 'bindata/base'
 
 class BaseStub < BinData::Base
   def clear; end
+  def clear?; end
   def single_value?; end
-  def field_names; end
-  def snapshot; end
   def done_read; end
   def _do_read(io) end
   def _do_write(io) end
   def _do_num_bytes; end
+  def _snapshot; end
 end
 
 describe BinData::Base, "with mandatory parameters" do
@@ -220,20 +220,21 @@ describe BinData::Base, "with :adjust_offset" do
   end
 end
 
-describe BinData::Base, "with :readwrite => false" do
+describe BinData::Base, "with :onlyif => false" do
   before(:all) do
     eval <<-END
-      class NoIOBase < BaseStub
+      class OnlyIfBase < BaseStub
         attr_accessor :mock
         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
+        def _snapshot; mock._snapshot; end
       end
     END
   end
 
   before(:each) do
-    @obj = NoIOBase.new :readwrite => false
+    @obj = OnlyIfBase.new :onlyif => false
     @obj.mock = mock('mock')
   end
 
@@ -253,22 +254,27 @@ describe BinData::Base, "with :readwrite => false" do
     @obj.mock.should_not_receive(:_do_num_bytes)
     @obj.num_bytes.should be_zero
   end
+
+  it "should have nil snapshot" do
+    @obj.mock.should_not_receive(:_snapshot)
+    @obj.snapshot.should be_nil
+  end
 end
 
-describe BinData::Base, "with :onlyif" do
+describe BinData::Base, "with :readwrite" do
   before(:all) do
     eval <<-END
-      class OnlyIfBase < BinData::Base
+      class NoIOBase < BinData::Base
         public :has_param?, :param
       end
     END
   end
 
-  it "should alias to :readwrite" do
-    obj = OnlyIfBase.new(:onlyif => "a")
-    obj.should_not have_param(:onlyif)
-    obj.should have_param(:readwrite)
-    obj.param(:readwrite).should == "a"
+  it "should alias to :onlyif" do
+    obj = NoIOBase.new(:readwrite => "a")
+    obj.should_not have_param(:readwrite)
+    obj.should have_param(:onlyif)
+    obj.param(:onlyif).should == "a"
   end
 end
 
@@ -276,7 +282,7 @@ describe BinData::Base, "when subclassing" do
   before(:all) do
     eval <<-END
       class SubClassOfBase < BinData::Base
-        public :_do_read, :_do_write, :_do_num_bytes
+        public :_do_read, :_do_write, :_do_num_bytes, :_snapshot
       end
     END
   end
@@ -286,17 +292,14 @@ describe BinData::Base, "when subclassing" do
   end
 
   it "should raise errors on unimplemented methods" do
-    lambda {
-      SubClassOfBase.all_possible_field_names(nil)
-    }.should raise_error(NotImplementedError)
     lambda { @obj.clear }.should raise_error(NotImplementedError)
+    lambda { @obj.clear? }.should raise_error(NotImplementedError)
     lambda { @obj.single_value? }.should raise_error(NotImplementedError)
-    lambda { @obj.field_names }.should raise_error(NotImplementedError)
-    lambda { @obj.snapshot }.should raise_error(NotImplementedError)
     lambda { @obj.done_read }.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 { @obj._snapshot }.should raise_error(NotImplementedError)
   end
 end
 

data/spec/bits_spec.rb

@@ -115,14 +115,14 @@ describe "All bitfields" do
 
           min = 0
           max = (1 << nbits) - 1
-          range = [min .. max]
+          range = (min .. max)
 
           values = []
           values << (min + 1) if range.include?(min + 1)
           values << (min + 3) if range.include?(min + 3)
           values << (max - 1) if range.include?(max - 1)
 
-          value.each do |val|
+          values.each do |val|
             obj = klass.new
             obj.value = val
             str = obj.to_s

data/spec/choice_spec.rb

@@ -44,28 +44,6 @@ describe BinData::Choice, "when instantiating" do
     args = {:choices => {nil => :int8}, :selection => 0}
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
   end
-
-  it "should fail on all_possible_field_names with unsanitized parameters" do
-    lambda {
-      BinData::Choice.all_possible_field_names({})
-    }.should raise_error(ArgumentError)
-  end
-
-  it "should return all possible field names for :choices Hash" do
-    choices = {0 => [:struct, {:fields => [[:int8, :a], [:int8, :b]]}],
-               1 => [:struct, {:fields => [[:int8, :c]]}]}
-    args = {:choices => choices, :selection => 0}
-    params = BinData::SanitizedParameters.new(BinData::Choice, args)
-    BinData::Choice.all_possible_field_names(params).should == ["a", "b", "c"]
-  end
-
-  it "should return all possible field names for :choices Array" do
-    choices = [[:struct, {:fields => [[:int8, :a], [:int8, :b]]}],
-               [:struct, {:fields => [[:int8, :c]]}]]
-    args = {:choices => choices, :selection => 0}
-    params = BinData::SanitizedParameters.new(BinData::Choice, args)
-    BinData::Choice.all_possible_field_names(params).should == ["a", "b", "c"]
-  end
 end
 
 describe BinData::Choice, "with choices array" do
@@ -108,9 +86,7 @@ describe BinData::Choice, "with choices array" do
   it "should delegate methods to the selected single choice" do
     @chooser.choice = 1
 
-    @data.find_obj_for_name("does_not_exist").should be_nil
     @data.num_bytes.should == 2
-    @data.field_names.should be_empty
   end
 end
 

data/spec/multi_value_spec.rb

@@ -182,7 +182,7 @@ describe BinData::MultiValue, "with nested structs" do
       class MultiValueOuter < BinData::MultiValue
         int8               :a, :initial_value => 6
         multi_value_inner1 :b, :the_val => :a
-        multi_value_inner2 nil
+        multi_value_inner2 :c
       end
     END
   end
@@ -192,20 +192,19 @@ describe BinData::MultiValue, "with nested structs" do
   end
 
   it "should included nested field names" do
-    @obj.field_names.should == ["a", "b", "y", "z"]
+    @obj.field_names.should == ["a", "b", "c"]
   end
 
   it "should access nested fields" do
     @obj.a.should   == 6
     @obj.b.w.should == 3
     @obj.b.x.should == 6
-    @obj.y.should   == 3
+    @obj.c.y.should == 3
   end
 
   it "should return correct offset of" do
     @obj.offset_of("b").should == 1
-    @obj.offset_of("y").should == 3
-    @obj.offset_of("z").should == 4
+    @obj.offset_of("c").should == 3
   end
 end
 
@@ -248,3 +247,45 @@ describe BinData::MultiValue, "with an endian defined" do
     io.read.should == expected
   end
 end
+
+describe BinData::MultiValue, "defined recursively" do
+  before(:all) do
+    eval <<-END
+      class RecursiveMultiValue < BinData::MultiValue
+        endian  :big
+        uint16  :val
+        uint8   :has_nxt, :value => lambda { nxt.clear? ? 0 : 1 }
+        recursive_multi_value :nxt, :onlyif => lambda { has_nxt > 0 }
+      end
+    END
+  end
+
+  it "should be able to be created" do
+    obj = RecursiveMultiValue.new
+  end
+
+  it "should read" do
+    str = "\x00\x01\x01\x00\x02\x01\x00\x03\x00"
+    obj = RecursiveMultiValue.read(str)
+    obj.val.should == 1
+    obj.nxt.val.should == 2
+    obj.nxt.nxt.val.should == 3
+  end
+
+  it "should be assignable on demand" do
+    obj = RecursiveMultiValue.new
+    obj.val = 13
+    obj.nxt.val = 14
+    obj.nxt.nxt.val = 15
+  end
+
+  it "should write" do
+    obj = RecursiveMultiValue.new
+    obj.val = 5
+    obj.nxt.val = 6
+    obj.nxt.nxt.val = 7
+    obj.to_s.should == "\x00\x05\x01\x00\x06\x01\x00\x07\x00"
+  end
+
+end
+

data/spec/sanitize_spec.rb

@@ -2,25 +2,64 @@
 
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/sanitize'
+require 'bindata/int'
 
-describe BinData::SanitizedParameters, "with nil parameters" do
+describe BinData::Sanitizer, "class methods" do
+  it "should resolve type with endian" do
+    BinData::Sanitizer.type_exists?(:int16, :little).should be_true
+  end
+
+  it "should return if type exists" do
+    BinData::Sanitizer.type_exists?(:int8).should be_true
+  end
+
+  it "should raise if type doesn't exist" do
+    BinData::Sanitizer.type_exists?(:does_not_exist).should be_false
+  end
+
+  it "should lookup types" do
+    BinData::Sanitizer.lookup(:int16, :little).should == BinData::Int16le
+  end
+
+end
+
+describe BinData::Sanitizer do
   before(:each) do
-    @mock = mock("dummy class")
-    @mock.stub!(:accepted_parameters).and_return([:a, :b, :c])
+    @sanitizer = BinData::Sanitizer.new
   end
 
-  it "should return empty parameters" do
-    @mock.should_receive(:sanitize_parameters).with({}).and_return({})
+  it "should raise error on unknown types" do
+    lambda {
+      @sanitizer.sanitize(:does_not_exist, {})
+    }.should raise_error(TypeError)
+  end
 
-    sanitized = BinData::SanitizedParameters.new(@mock, nil)
-    sanitized.keys.should be_empty
+  it "should lookup when endian is set" do
+    @sanitizer.with_endian(:little) do
+      klass, params = @sanitizer.sanitize(:int16, {})
+      klass.should == BinData::Int16le
+    end
   end
 
-  it "should pass extra arguments" do
-    @mock.should_receive(:sanitize_parameters).with({}, 1, 2, 3).and_return({})
+  it "should nest with_endian calls" do
+    @sanitizer.with_endian(:little) do
+      klass, params = @sanitizer.sanitize(:int16, {})
+      klass.should == BinData::Int16le
+
+      @sanitizer.with_endian(:big) do
+        klass, params = @sanitizer.sanitize(:int16, {})
+        klass.should == BinData::Int16be
+      end
+
+      klass, params = @sanitizer.sanitize(:int16, {})
+      klass.should == BinData::Int16le
+    end
+  end
 
-    sanitized = BinData::SanitizedParameters.new(@mock, nil, 1, 2, 3)
-    sanitized.keys.should be_empty
+  it "should sanitize parameters" do
+    klass, params = @sanitizer.sanitize(:int8, {:value => 3})
+    klass.should == BinData::Int8
+    params.should have_key(:value)
   end
 end
 
@@ -33,9 +72,6 @@ describe BinData::SanitizedParameters, "with bad input" do
 
   it "should convert keys to symbols" do
     the_params = {'a' => 1, 'b' => 2, 'e' => 5}
-    @mock.should_receive(:sanitize_parameters).with(the_params).
-      and_return { |params, *rest| params }
-
     sanitized = BinData::SanitizedParameters.new(@mock, the_params)
     sanitized.accepted_parameters.should == ({:a => 1, :b => 2})
     sanitized.extra_parameters.should == ({:e => 5})
@@ -43,9 +79,6 @@ describe BinData::SanitizedParameters, "with bad input" do
 
   it "should raise error if parameter has nil value" do
     the_params = {'a' => 1, 'b' => nil, 'e' => 5}
-    @mock.should_receive(:sanitize_parameters).with(the_params).
-      and_return { |params, *rest| params }
-
     lambda {
       BinData::SanitizedParameters.new(@mock, the_params)
     }.should raise_error(ArgumentError)
@@ -59,26 +92,13 @@ describe BinData::SanitizedParameters do
     @params = {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
   end
 
-  it "should pass extra arguments" do
-    @mock.should_receive(:sanitize_parameters).with(@params, 1, 2, 3).
-      and_return { |params, *rest| params }
-
-    sanitized = BinData::SanitizedParameters.new(@mock, @params, 1, 2, 3)
-  end
-
   it "should partition" do
-    @mock.should_receive(:sanitize_parameters).with(@params).
-      and_return { |params, *rest| params }
-
     sanitized = BinData::SanitizedParameters.new(@mock, @params)
     sanitized.accepted_parameters.should == ({:a => 1, :b => 2, :c => 3})
     sanitized.extra_parameters.should == ({:d => 4, :e => 5})
   end
 
   it "should respond_to keys" do
-    @mock.should_receive(:sanitize_parameters).with(@params).
-      and_return { |params, *rest| params }
-
     sanitized = BinData::SanitizedParameters.new(@mock, @params)
     sanitized.should respond_to(:keys)
     keys = sanitized.keys.collect { |x| x.to_s }
@@ -86,9 +106,6 @@ describe BinData::SanitizedParameters do
   end
 
   it "should respond_to has_key?" do
-    @mock.should_receive(:sanitize_parameters).with(@params).
-      and_return { |params, *rest| params }
-
     sanitized = BinData::SanitizedParameters.new(@mock, @params)
     sanitized.should respond_to(:has_key?)
     sanitized.has_key?(:a).should be_true
@@ -97,9 +114,6 @@ describe BinData::SanitizedParameters do
   end
 
   it "should respond_to []" do
-    @mock.should_receive(:sanitize_parameters).with(@params).
-      and_return { |params, *rest| params }
-
     sanitized = BinData::SanitizedParameters.new(@mock, @params)
     sanitized.should respond_to(:[])
     sanitized[:a].should == 1