bindata 0.8.1 → 0.9.0

data/spec/choice_spec.rb

@@ -6,7 +6,11 @@ require 'bindata/int'
 require 'bindata/lazy'
 require 'bindata/struct'
 
-describe "Instantiating a Choice" do
+class Chooser
+  attr_accessor :choice
+end
+
+describe BinData::Choice, "when instantiating" do
   it "should ensure mandatory parameters are supplied" do
     args = {}
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
@@ -20,52 +24,81 @@ describe "Instantiating a Choice" do
     args = {:choices => [:does_not_exist], :selection => 0}
     lambda { BinData::Choice.new(args) }.should raise_error(TypeError)
   end
+
+  it "should fail if a given type is unknown" do
+    args = {:choices => {0 => :does_not_exist}, :selection => 0}
+    lambda { BinData::Choice.new(args) }.should raise_error(TypeError)
+  end
+
+  it "should fail if :choices isn't an Array or Hash" do
+    args = {:choices => :does_not_exist, :selection => 0}
+    lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
+  end
+
+  it "should fail if :choices Hash has a symbol as key" do
+    args = {:choices => {:a => :int8}, :selection => 0}
+    lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
+  end
+
+  it "should fail if :choices Hash has a nil key" 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 "A Choice with several choices" do
+describe BinData::Choice, "with choices array" do
   before(:each) do
-    # allow specifications to select the choice
-    @env = BinData::LazyEvalEnv.new
-    @env.class.class_eval { attr_accessor :choose }
-
-    @data = BinData::Choice.new({:choices => [[:int8, {:initial_value => 3}],
-                                              [:int16le, {:initial_value => 5}],
-                                              :int8,
-                                              [:struct,
-                                               {:fields =>[[:int8, :a]]}],
-                                              [:int8, {:initial_value => 7}]],
-                                 :selection => :choose},
-                                @env)
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices => [[:int8,    {:value => 3}],
+                                             [:int16le, {:value => 5}],
+                                             [:int32le, {:value => 7}]],
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
   end
 
   it "should be able to select the choice" do
-    @env.choose = 0
-    @data.value.should eql(3)
-    @env.choose = 1
-    @data.value.should eql(5)
-    @env.choose = 2
-    @data.value.should eql(0)
-    @env.choose = 3
-    @data.a.should eql(0)
-    @env.choose = 4
-    @data.value.should eql(7)
+    @chooser.choice = 0
+    @data.value.should == 3
+    @chooser.choice = 1
+    @data.value.should == 5
+    @chooser.choice = 2
+    @data.value.should == 7
   end
 
-  it "should not be able to select an invalid choice" do
-    @env.choose = -1
-    lambda { @data.value }.should raise_error(IndexError)
-    @env.choose = 5
+  it "should handle :selection returning nil" do
+    @chooser.choice = nil
     lambda { @data.value }.should raise_error(IndexError)
   end
 
-  it "should be able to interact directly with the choice" do
-    @env.choose = 0
-    @data.value = 17
-    @data.value.should eql(17)
+  it "should not be able to select an invalid choice" do
+    @chooser.choice = 99
+    lambda { @data.value }.should raise_error(IndexError)
   end
 
   it "should handle missing methods correctly" do
-    @env.choose = 0
+    @chooser.choice = 0
 
     @data.should respond_to(:value)
     @data.should_not respond_to(:does_not_exist)
@@ -73,33 +106,121 @@ describe "A Choice with several choices" do
   end
 
   it "should delegate methods to the selected single choice" do
-    @env.choose = 1
-    @data.value = 17
+    @chooser.choice = 1
 
     @data.find_obj_for_name("does_not_exist").should be_nil
-    @data.num_bytes.should eql(2)
+    @data.num_bytes.should == 2
     @data.field_names.should be_empty
-    @data.value.should eql(17)
+  end
+end
+
+describe BinData::Choice, "with sparse choices array" do
+  before(:each) do
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices => [nil, nil, nil,
+                                             [:int8,    {:value => 3}],
+                                             nil,
+                                             [:int16le, {:value => 5}],
+                                             nil,
+                                             [:int32le, {:value => 7}]],
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
+  end
+
+  it "should be able to select the choice" do
+    @chooser.choice = 3
+    @data.value.should == 3
+    @chooser.choice = 7
+    @data.value.should == 7
+  end
+
+  it "should not be able to select an invalid choice" do
+    @chooser.choice = 99
+    lambda { @data.value }.should raise_error(IndexError)
+  end
+
+  it "should not be able to select a nil choice" do
+    @chooser.choice = 1
+    lambda { @data.value }.should raise_error(IndexError)
+  end
+end
 
-    io = StringIO.new
-    @data.write(io)
+describe BinData::Choice, "with choices hash" do
+  before(:each) do
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices => {3 => [:int8,    {:value => 3}],
+                                             5 => [:int16le, {:value => 5}],
+                                             7 => [:int32le, {:value => 7}]},
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
+  end
 
-    @data.clear
-    @data.clear?.should be_true
-    @data.value.should eql(5)
+  it "should be able to select the choice" do
+    @chooser.choice = 3
+    @data.value.should == 3
+    @chooser.choice = 7
+    @data.value.should == 7
+  end
 
-    io.rewind
-    @data.read(io)
-    @data.value.should eql(17)
+  it "should not be able to select an invalid choice" do
+    @chooser.choice = 99
+    lambda { @data.value }.should raise_error(IndexError)
+  end
+end
 
-    @data.snapshot.should eql(17)
+describe BinData::Choice, "with single values" do
+  before(:each) do
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices => {3 => :uint8,
+                                             5 => :uint16le,
+                                             7 => :uint32le,},
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
   end
 
-  it "should delegate methods to the selected complex choice" do
-    @env.choose = 3
-    @data.find_obj_for_name("a").should_not be_nil
-    @data.field_names.should eql(["a"])
-    @data.num_bytes.should eql(1)
+  it "should copy value when changing selection" do
+    @chooser.choice = 3
+    @data.value = 254
+
+    @data.to_s.should == "\xfe"
+
+    @chooser.choice = 5
+    @data.to_s.should == "\xfe\x00"
+
+    @chooser.choice = 7
+    @data.to_s.should == "\xfe\x00\x00\x00"
   end
 end
 
+describe BinData::Choice, "with multi values" do
+  before(:each) do
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices =>
+                                  {3 => [:struct, {:fields => [[:int8,  :a]]}],
+                                   5 => [:struct, {:fields => [[:int8,  :a]]}]},
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
+  end
+
+  it "should access fields" do
+    @chooser.choice = 3
+    @data.a = 5
+    @data.a.should == 5
+  end
+
+  it "should not copy values when changing fields" do
+    @chooser.choice = 3
+    @data.a = 5
+    @data.a.should == 5
+
+    @chooser.choice = 5
+    @data.a = 17
+    @data.a.should == 17
+
+    @chooser.choice = 3
+    @data.a.should == 5
+
+    @chooser.choice = 5
+    @data.a.should == 17
+  end
+end

data/spec/int_spec.rb

@@ -12,7 +12,7 @@ describe "All signed integers" do
      BinData::Int32be,
      BinData::Int64le,
      BinData::Int64be].each do |klass|
-      klass.new.value.should eql(0)
+      klass.new.value.should be_zero
     end
   end
 
@@ -42,7 +42,7 @@ describe "All unsigned integers" do
      BinData::Uint32be,
      BinData::Uint64le,
      BinData::Uint64be].each do |klass|
-      klass.new.value.should eql(0)
+      klass.new.value.should be_zero
     end
   end
 
@@ -68,7 +68,7 @@ def test_read_write(klass, val, clamped_val, str)
   # set the data and ensure clamping occurs
   data = klass.new
   data.value = val
-  data.value.should eql(clamped_val)
+  data.value.should == clamped_val
   
   # write the data
   io = StringIO.new
@@ -76,13 +76,13 @@ def test_read_write(klass, val, clamped_val, str)
 
   # check that we write the expected byte pattern
   io.rewind
-  io.read.should eql(str)
+  io.read.should == str
 
   # check that we read in the same data that was written
   io.rewind
   data = klass.new
   data.read(io)
-  data.value.should eql(clamped_val)
+  data.value.should == clamped_val
 end
 
 # return test data for testing unsigned ints

data/spec/lazy_spec.rb

@@ -12,31 +12,34 @@ class MockDataObject
   end
 end
 
-describe "A single environment" do
+describe BinData::LazyEvalEnv do
   before(:each) do
     @do1 = MockDataObject.new(:f1 => 'f1')
     @e1 = BinData::LazyEvalEnv.new
     @e1.data_object = @do1
     @e1.add_variable(:v1, 'v1')
+    @e1.add_variable(:v2, 'v2')
   end
 
   it "should accept symbols as a shortcut to lambda" do
-    @e1.lazy_eval(lambda { o1 }, :o1 => 'o1').should eql('o1')
-    @e1.lazy_eval(lambda { v1 }).should eql('v1')
-    @e1.lazy_eval(:o1, :o1 => 'o1').should eql('o1')
-    @e1.lazy_eval(:v1).should eql('v1')
+    @e1.lazy_eval(lambda { o1 }, :o1 => 'o1').should == 'o1'
+    @e1.lazy_eval(lambda { v1 }).should == 'v1'
+    @e1.lazy_eval(:o1, :o1 => 'o1').should == 'o1'
+    @e1.lazy_eval(:v1).should == 'v1'
+    @e1.lazy_eval(:v2).should == 'v2'
   end
 
   it "should evaluate overrides" do
-    @e1.lazy_eval(:o1, :o1 => 'o1').should eql('o1')
+    @e1.lazy_eval(:o1, :o1 => 'o1').should == 'o1'
   end
 
   it "should evaluate variables" do
-    @e1.lazy_eval(:v1).should eql('v1')
+    @e1.lazy_eval(:v1).should == 'v1'
+    @e1.lazy_eval(:v2).should == 'v2'
   end
 
   it "should prioritise overrides over variables" do
-    @e1.lazy_eval(:v1, :v1 => 'o1').should eql('o1')
+    @e1.lazy_eval(:v1, :v1 => 'o1').should == 'o1'
   end
 
   it "should not resolve any unknown fields" do
@@ -46,7 +49,7 @@ describe "A single environment" do
   end
 end
 
-describe "An environment with one parent" do
+describe BinData::LazyEvalEnv, "with one parent" do
   before(:each) do
     @do2 = MockDataObject.new(:f2 => 'f2', :common1 => 'f2', :common2 => 'f2')
     @do1 = MockDataObject.new
@@ -64,23 +67,23 @@ describe "An environment with one parent" do
   end
 
   it "should evaluate parent parameter" do
-    @e1.lazy_eval(:p2).should eql('p2')
+    @e1.lazy_eval(:p2).should == 'p2'
   end
 
   it "should evaluate parent field" do
-    @e1.lazy_eval(:f2).should eql('f2')
+    @e1.lazy_eval(:f2).should == 'f2'
   end
 
   it "should prefer parent param over parent field" do
-    @e1.lazy_eval(:common1).should eql('p2')
+    @e1.lazy_eval(:common1).should == 'p2'
   end
 
   it "should prefer variable over parent param" do
-    @e1.lazy_eval(:common2).should eql('v1')
+    @e1.lazy_eval(:common2).should == 'v1'
   end
 end
 
-describe "A nested environment" do
+describe BinData::LazyEvalEnv, "when nested" do
   before(:each) do
     @do4 = MockDataObject.new(:f4 => 'f4')
     @do3 = MockDataObject.new(:f3 => 'f3')
@@ -105,20 +108,20 @@ describe "A nested environment" do
   end
 
   it "should access parent environments" do
-    @e1.lazy_eval(lambda { parent.p3 }).should eql('p3')
-    @e1.lazy_eval(lambda { parent.parent.p4 }).should eql('p4')
+    @e1.lazy_eval(lambda { parent.p3 }).should == 'p3'
+    @e1.lazy_eval(lambda { parent.parent.p4 }).should == 'p4'
   end
 
   it "should cascade lambdas" do
-    @e1.lazy_eval(lambda { l2 }).should eql('l4')
-    @e1.lazy_eval(lambda { s2 }).should eql('s4')
+    @e1.lazy_eval(lambda { l2 }).should == 'l4'
+    @e1.lazy_eval(lambda { s2 }).should == 's4'
   end
 
   it "should access parent environments by cascading" do
-    @e1.lazy_eval(lambda { p3 }).should eql('p3')
-    @e1.lazy_eval(lambda { p4 }).should eql('p4')
-    @e1.lazy_eval(lambda { v2 }).should eql('v2')
-    @e1.lazy_eval(lambda { s3 }).should eql('s4')
-    @e1.lazy_eval(lambda { fs2 }).should eql('s4')
+    @e1.lazy_eval(lambda { p3 }).should == 'p3'
+    @e1.lazy_eval(lambda { p4 }).should == 'p4'
+    @e1.lazy_eval(lambda { v2 }).should == 'v2'
+    @e1.lazy_eval(lambda { s3 }).should == 's4'
+    @e1.lazy_eval(lambda { fs2 }).should == 's4'
   end
 end

data/spec/multi_value_spec.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata'
+
+describe BinData::MultiValue, "with hidden fields" do
+  before(:all) do
+    eval <<-END
+      class HiddenMultiValue < BinData::MultiValue
+        hide :b, 'c'
+        int8 :a
+        int8 'b', :initial_value => 10
+        int8 :c
+        int8 :d, :value => :b
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = HiddenMultiValue.new
+  end
+
+  it "should only show fields that aren't hidden" do
+    @obj.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
+
+    @obj.should respond_to(:b=)
+  end
+
+  it "should not include hidden fields in snapshot" do
+    @obj.b = 5
+    @obj.snapshot.should == {"a" => 0, "d" => 5}
+  end
+end
+
+describe BinData::MultiValue, "when defining" do
+  it "should fail on non registered types" do
+    lambda {
+      eval <<-END
+        class BadTypeMultiValue < BinData::MultiValue
+          non_registerd_type :a
+        end
+      END
+    }.should raise_error(TypeError)
+  end
+
+  it "should fail on duplicate names" do
+    lambda {
+      eval <<-END
+        class DuplicateNameMultiValue < BinData::MultiValue
+          int8 :a
+          int8 :b
+          int8 :a
+        end
+      END
+    }.should raise_error(SyntaxError)
+  end
+
+  it "should fail on reserved names" do
+    lambda {
+      eval <<-END
+        class ReservedNameMultiValue < BinData::MultiValue
+          int8 :a
+          int8 :invert # from Hash.instance_methods
+        end
+      END
+    }.should raise_error(NameError)
+  end
+
+  it "should fail when field name shadows an existing method" do
+    lambda {
+      eval <<-END
+        class ExistingNameMultiValue < BinData::MultiValue
+          int8 :object_id
+        end
+      END
+    }.should raise_error(NameError)
+  end
+
+  it "should fail on unknown endian" do
+    lambda {
+      eval <<-END
+        class BadEndianMultiValue < BinData::MultiValue
+          endian 'a bad value'
+        end
+      END
+    }.should raise_error(ArgumentError)
+  end
+end
+
+describe BinData::MultiValue, "with multiple fields" do
+  before(:all) do
+    eval <<-END
+      class MultiFieldMultiValue < BinData::MultiValue
+        int8 :a
+        int8 :b
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = MultiFieldMultiValue.new
+    @obj.a = 1
+    @obj.b = 2
+  end
+
+  it "should return num_bytes" do
+    @obj.num_bytes(:a).should == 1
+    @obj.num_bytes(:b).should == 1
+    @obj.num_bytes.should     == 2
+  end
+
+  it "should identify accepted parameters" do
+    BinData::MultiValue.accepted_parameters.should include(:hide)
+    BinData::MultiValue.accepted_parameters.should include(:endian)
+  end
+
+  it "should clear" do
+    @obj.a = 6
+    @obj.clear
+    @obj.clear?.should be_true
+  end
+
+  it "should clear individual elements" do
+    @obj.a = 6
+    @obj.b = 7
+    @obj.clear(:a)
+    @obj.clear?(:a).should be_true
+    @obj.clear?(:b).should be_false
+  end
+
+  it "should write ordered" do
+    io = StringIO.new
+    @obj.write(io)
+
+    io.rewind
+    io.read.should == "\x01\x02"
+  end
+
+  it "should read ordered" do
+    io = StringIO.new "\x03\x04"
+    @obj.read(io)
+
+    @obj.a.should == 3
+    @obj.b.should == 4
+  end
+
+  it "should return a snapshot" do
+    snap = @obj.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"]
+  end
+  
+  it "should fail on unknown method call" do
+    lambda { @obj.does_not_exist }.should raise_error(NoMethodError)
+  end
+end
+
+describe BinData::MultiValue, "with nested structs" do
+  before(:all) do
+    eval <<-END
+      class MultiValueInner1 < BinData::MultiValue
+        int8 :w, :initial_value => 3
+        int8 :x, :value => :the_val
+      end
+
+      class MultiValueInner2 < BinData::MultiValue
+        int8 :y, :value => lambda { parent.b.w }
+        int8 :z
+      end
+
+      class MultiValueOuter < BinData::MultiValue
+        int8               :a, :initial_value => 6
+        multi_value_inner1 :b, :the_val => :a
+        multi_value_inner2 nil
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = MultiValueOuter.new
+  end
+
+  it "should included nested field names" do
+    @obj.field_names.should == ["a", "b", "y", "z"]
+  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
+  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
+  end
+end
+
+describe BinData::MultiValue, "with an endian defined" do
+  before(:all) do
+    eval <<-END
+      class MultiValueWithEndian < BinData::MultiValue
+        endian :little
+
+        uint16 :a
+        float  :b
+        array  :c, :type => :int8, :initial_length => 2
+        choice :d, :choices => [ [:uint16], [:uint32] ], :selection => 1
+        struct :e, :fields => [ [:uint16, :f], [:uint32be, :g] ]
+        struct :h, :fields => [ [:struct, :i, {:fields => [[:uint16, :j]]}] ]
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = MultiValueWithEndian.new
+  end
+
+  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
+
+    expected = [1, 2.0, 3, 4, 5, 6, 7, 8].pack('veCCVvNv')
+
+    io = StringIO.new
+    @obj.write(io)
+
+    io.rewind
+    io.read.should == expected
+  end
+end