bindata 0.9.2 → 0.9.3

data/spec/base_spec.rb

@@ -18,7 +18,7 @@ describe BinData::Base, "with mandatory parameters" do
   before(:all) do
     eval <<-END
       class MandatoryBase < BinData::Base
-        mandatory_parameter :p1
+        bindata_mandatory_parameter :p1
       end
     END
   end
@@ -36,8 +36,8 @@ describe BinData::Base, "with default parameters" do
   before(:all) do
     eval <<-END
       class DefaultBase < BinData::Base
-        default_parameter :p1 => "a"
-        public :has_param?, :param
+        bindata_default_parameter :p1 => "a"
+        public :has_param?, :no_eval_param
       end
     END
   end
@@ -45,13 +45,13 @@ describe BinData::Base, "with default parameters" do
   it "should set default parameters if they are not specified" do
     obj = DefaultBase.new
     obj.should have_param(:p1)
-    obj.param(:p1).should == "a"
+    obj.no_eval_param(:p1).should == "a"
   end
 
   it "should be able to override default parameters" do
     obj = DefaultBase.new(:p1 => "b")
     obj.should have_param(:p1)
-    obj.param(:p1).should == "b"
+    obj.no_eval_param(:p1).should == "b"
   end
 end
 
@@ -59,8 +59,8 @@ describe BinData::Base, "with mutually exclusive parameters" do
   before(:all) do
     eval <<-END
       class MutexParamBase < BinData::Base
-        optional_parameters :p1, :p2
-        mutually_exclusive_parameters :p1, :p2
+        bindata_optional_parameters :p1, :p2
+        bindata_mutually_exclusive_parameters :p1, :p2
       end
     END
   end
@@ -83,10 +83,10 @@ describe BinData::Base, "with multiple parameters" do
   before(:all) do
     eval <<-END
       class WithParamBase < BinData::Base
-        mandatory_parameter :p1
-        optional_parameter  :p2
-        default_parameter   :p3 => '3'
-        public :has_param?, :eval_param, :param
+        bindata_mandatory_parameter :p1
+        bindata_optional_parameter  :p2
+        bindata_default_parameter   :p3 => '3'
+        public :has_param?, :eval_param, :no_eval_param
       end
     END
   end
@@ -96,10 +96,8 @@ describe BinData::Base, "with multiple parameters" do
   end
 
   it "should identify extra parameters" do
-    env = mock("env")
-    env.should_receive(:params=).with(:p4 => 4, :p5 => 5)
-    env.should_receive(:data_object=)
-    obj = WithParamBase.new({:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5}, env)
+    obj = WithParamBase.new({:p1 => 1, :p3 => 3, :p4 => 4, :p5 => 5})
+    obj.parameters.should == {:p4 => 4, :p5 => 5}
   end
 
   it "should only recall mandatory, default and optional parameters" do
@@ -122,17 +120,17 @@ describe BinData::Base, "with multiple parameters" do
 
   it "should be able to access without evaluating" do
     obj = WithParamBase.new(:p1 => :asym, :p3 => lambda {1 + 2})
-    obj.param(:p1).should == :asym
-    obj.param(:p2).should be_nil
-    obj.param(:p3).should respond_to(:arity)
+    obj.no_eval_param(:p1).should == :asym
+    obj.no_eval_param(:p2).should be_nil
+    obj.no_eval_param(:p3).should respond_to(:arity)
   end
 
   it "should identify accepted parameters" do
-    accepted_parameters = WithParamBase.accepted_parameters
-    accepted_parameters.should include(:p1)
-    accepted_parameters.should include(:p2)
-    accepted_parameters.should include(:p3)
-    accepted_parameters.should_not include(:p4)
+    internal_parameters = WithParamBase.internal_parameters
+    internal_parameters.should include(:p1)
+    internal_parameters.should include(:p2)
+    internal_parameters.should include(:p3)
+    internal_parameters.should_not include(:p4)
   end
 end
 
@@ -265,7 +263,7 @@ describe BinData::Base, "with :readwrite" do
   before(:all) do
     eval <<-END
       class NoIOBase < BinData::Base
-        public :has_param?, :param
+        public :has_param?, :no_eval_param
       end
     END
   end
@@ -274,7 +272,7 @@ describe BinData::Base, "with :readwrite" do
     obj = NoIOBase.new(:readwrite => "a")
     obj.should_not have_param(:readwrite)
     obj.should have_param(:onlyif)
-    obj.param(:onlyif).should == "a"
+    obj.no_eval_param(:onlyif).should == "a"
   end
 end
 

data/spec/choice_spec.rb

@@ -30,11 +30,6 @@ describe BinData::Choice, "when instantiating" do
     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)
@@ -58,10 +53,15 @@ describe BinData::Choice, "with choices array" do
 
   it "should be able to select the choice" do
     @chooser.choice = 0
+    @data.selection.should == 0
     @data.value.should == 3
+
     @chooser.choice = 1
+    @data.selection.should == 1
     @data.value.should == 5
+
     @chooser.choice = 2
+    @data.selection.should == 2
     @data.value.should == 7
   end
 
@@ -105,8 +105,11 @@ describe BinData::Choice, "with sparse choices array" do
 
   it "should be able to select the choice" do
     @chooser.choice = 3
+    @data.selection.should == 3
     @data.value.should == 3
+
     @chooser.choice = 7
+    @data.selection.should == 7
     @data.value.should == 7
   end
 
@@ -134,8 +137,11 @@ describe BinData::Choice, "with choices hash" do
   it "should be able to select the choice" do
     @chooser.choice = 3
     @data.value.should == 3
+    @data.selection.should == 3
+
     @chooser.choice = 7
     @data.value.should == 7
+    @data.selection.should == 7
   end
 
   it "should not be able to select an invalid choice" do

data/spec/int_spec.rb

@@ -11,20 +11,24 @@ describe "All signed integers" do
      BinData::Int32le,
      BinData::Int32be,
      BinData::Int64le,
-     BinData::Int64be].each do |klass|
+     BinData::Int64be,
+     BinData::Int128le,
+     BinData::Int128be].each do |klass|
       klass.new.value.should be_zero
     end
   end
 
   it "should pass these tests" do
     [
-      [1, true,  BinData::Int8],
-      [2, false, BinData::Int16le],
-      [2, true,  BinData::Int16be],
-      [4, false, BinData::Int32le],
-      [4, true,  BinData::Int32be],
-      [8, false, BinData::Int64le],
-      [8, true,  BinData::Int64be],
+      [ 1, true,  BinData::Int8],
+      [ 2, false, BinData::Int16le],
+      [ 2, true,  BinData::Int16be],
+      [ 4, false, BinData::Int32le],
+      [ 4, true,  BinData::Int32be],
+      [ 8, false, BinData::Int64le],
+      [ 8, true,  BinData::Int64be],
+      [16, false, BinData::Int128le],
+      [16, true,  BinData::Int128be],
     ].each do |nbytes, big_endian, klass|
       gen_int_test_data(nbytes, big_endian).each do |val, clamped_val, str|
         test_read_write(klass, val, clamped_val, str)
@@ -41,20 +45,24 @@ describe "All unsigned integers" do
      BinData::Uint32le,
      BinData::Uint32be,
      BinData::Uint64le,
-     BinData::Uint64be].each do |klass|
+     BinData::Uint64be,
+     BinData::Uint128le,
+     BinData::Uint128be].each do |klass|
       klass.new.value.should be_zero
     end
   end
 
   it "should pass these tests" do
     [
-      [1, true,  BinData::Uint8],
-      [2, false, BinData::Uint16le],
-      [2, true,  BinData::Uint16be],
-      [4, false, BinData::Uint32le],
-      [4, true,  BinData::Uint32be],
-      [8, false, BinData::Uint64le],
-      [8, true,  BinData::Uint64be],
+      [ 1, true,  BinData::Uint8],
+      [ 2, false, BinData::Uint16le],
+      [ 2, true,  BinData::Uint16be],
+      [ 4, false, BinData::Uint32le],
+      [ 4, true,  BinData::Uint32be],
+      [ 8, false, BinData::Uint64le],
+      [ 8, true,  BinData::Uint64be],
+      [16, false, BinData::Uint128le],
+      [16, true,  BinData::Uint128be],
     ].each do |nbytes, big_endian, klass|
       gen_uint_test_data(nbytes, big_endian).each do |val, clamped_val, str|
         test_read_write(klass, val, clamped_val, str)
@@ -87,11 +95,14 @@ end
 
 # return test data for testing unsigned ints
 def gen_uint_test_data(nbytes, big_endian)
-  raise "nbytes too big" if nbytes > 8
+  raise "nbytes too large" if nbytes > 16
   tests = []
 
+  max_value = (1 << (nbytes * 8)) - 1
+  min_value = 0
+
   # test the minimum value
-  v = 0
+  v = min_value
   s = "\x00" * nbytes
   tests.push [v, v, big_endian ? s : s.reverse]
 
@@ -99,12 +110,12 @@ def gen_uint_test_data(nbytes, big_endian)
   tests.push [v-1, v, big_endian ? s : s.reverse]
 
   # test a value within range
-  v = 0x123456789abcdef0 >> ((8-nbytes) * 8)
-  s = "\x12\x34\x56\x78\x9a\xbc\xde\xf0".slice(0, nbytes)
+  v = 0x123456789abcdef0123456789abcdef0 >> ((16-nbytes) * 8)
+  s = "\x12\x34\x56\x78\x9a\xbc\xde\xf0\x12\x34\x56\x78\x9a\xbc\xde\xf0".slice(0, nbytes)
   tests.push [v, v, big_endian ? s : s.reverse]
 
   # test the maximum value
-  v = (1 << (nbytes * 8)) - 1
+  v = max_value
   s = "\xff" * nbytes
   tests.push [v, v, big_endian ? s : s.reverse]
 
@@ -116,12 +127,15 @@ end
 
 # return test data for testing signed ints
 def gen_int_test_data(nbytes, big_endian)
-  raise "nbytes too big" if nbytes > 8
+  raise "nbytes too large" if nbytes > 16
   tests = []
 
+  max_value = (1 << (nbytes * 8 - 1)) - 1
+  min_value = -max_value - 1
+
   # test the minimum value
-  v = -((1 << (nbytes * 8 - 1)) - 1) -1
-  s = "\x80\x00\x00\x00\x00\x00\x00\x00".slice(0, nbytes)
+  v = min_value
+  s = "\x80" + "\x00" * (nbytes - 1)
   tests.push [v, v, big_endian ? s : s.reverse]
 
   # values below minimum should be clamped to minimum
@@ -133,12 +147,12 @@ def gen_int_test_data(nbytes, big_endian)
   tests.push [v, v, big_endian ? s : s.reverse]
 
   # test a +ve value within range
-  v = 0x123456789abcdef0 >> ((8-nbytes) * 8)
-  s = "\x12\x34\x56\x78\x9a\xbc\xde\xf0".slice(0, nbytes)
+  v = 0x123456789abcdef0123456789abcdef0 >> ((16-nbytes) * 8)
+  s = "\x12\x34\x56\x78\x9a\xbc\xde\xf0\x12\x34\x56\x78\x9a\xbc\xde\xf0".slice(0, nbytes)
   tests.push [v, v, big_endian ? s : s.reverse]
 
   # test the maximum value
-  v = (1 << (nbytes * 8 - 1)) - 1
+  v = max_value
   s = "\x7f" + "\xff" * (nbytes - 1)
   tests.push [v, v, big_endian ? s : s.reverse]
 

data/spec/lazy_spec.rb

@@ -1,127 +1,160 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/array'
+require 'bindata/int'
 require 'bindata/lazy'
 
 # A mock data object with customizable fields.
 class MockDataObject
-  def initialize(fields = {})
-    fields.each do |k,v|
-      self.class.send(:define_method, k.to_sym) { v }
+  def initialize(methods = {}, params = {}, parent = nil)
+    methods.each do |k,v|
+      meta = class << self ; self; end
+      meta.send(:define_method, k.to_sym) { v }
     end
+    @parameters = params
+    @parent = parent
   end
+  attr_accessor :parent, :parameters
 end
 
-describe BinData::LazyEvalEnv do
+describe BinData::LazyEvaluator, "with no parents" 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 == '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'
+    methods = {:m1 => 'm1', :com => 'mC'}
+    params  = {:p1 => 'p1', :com => 'pC'}
+    obj = MockDataObject.new(methods, params)
+    @ev = BinData::LazyEvaluator.new(obj)
   end
 
   it "should evaluate overrides" do
-    @e1.lazy_eval(:o1, :o1 => 'o1').should == 'o1'
+    @ev.lazy_eval(lambda { o1 }, :o1 => 'o1').should == 'o1'
   end
 
-  it "should evaluate variables" do
-    @e1.lazy_eval(:v1).should == 'v1'
-    @e1.lazy_eval(:v2).should == 'v2'
+  it "should not resolve any unknown methods" do
+    lambda { @ev.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+    lambda { @ev.lazy_eval(lambda { m1 }) }.should raise_error(NameError)
+    lambda { @ev.lazy_eval(lambda { p1 }) }.should raise_error(NameError)
   end
 
-  it "should prioritise overrides over variables" do
-    @e1.lazy_eval(:v1, :v1 => 'o1').should == 'o1'
+  it "should not have a parent" do
+    @ev.lazy_eval(lambda { parent }).should be_nil
   end
 
-  it "should not resolve any unknown fields" do
-    lambda { @e1.lazy_eval(:unknown) }.should raise_error(NameError)
-    lambda { @e1.lazy_eval(:p1) }.should raise_error(NameError)
-    lambda { @e1.lazy_eval(:f1) }.should raise_error(NameError)
+  it "should not resolve #index" do
+    lambda { @ev.lazy_eval(lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
-describe BinData::LazyEvalEnv, "with one parent" do
+describe BinData::LazyEvaluator, "with one parent" do
   before(:each) do
-    @do2 = MockDataObject.new(:f2 => 'f2', :common1 => 'f2', :common2 => 'f2')
-    @do1 = MockDataObject.new
+    parent_methods = {:m1 => 'Pm1', :com => 'PmC', :mm => 3}
+    parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
+    parent_obj = MockDataObject.new(parent_methods, parent_params)
+
+    methods = {:m1 => 'm1', :com => 'mC'}
+    params  = {:p1 => 'p1', :com => 'pC'}
+    obj = MockDataObject.new(methods, params, parent_obj)
 
-    @e2 = BinData::LazyEvalEnv.new
-    @e1 = BinData::LazyEvalEnv.new(@e2)
+    @ev = BinData::LazyEvaluator.new(obj)
+  end
 
-    @e2.data_object = @do2
-    @e1.data_object = @do1
+  it "should evaluate overrides" do
+    @ev.lazy_eval(lambda { p1 }, :p1 => 'o1').should == 'o1'
+  end
 
-    @e1.add_variable(:common2, 'v1')
+  it "should not resolve any unknown methods" do
+    lambda { @ev.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+  end
 
-    @e2.params = {:p2 => 'p2', :common1 => 'p2', :common2 => 'p2'}
-    @e2.add_variable(:common2, 'v2')
+  it "should resolve parameters in the parent" do
+    @ev.lazy_eval(lambda { p1 }).should == 'Pp1'
   end
 
-  it "should evaluate parent parameter" do
-    @e1.lazy_eval(:p2).should == 'p2'
+  it "should resolve methods in the parent" do
+    @ev.lazy_eval(lambda { m1 }).should == 'Pm1'
   end
 
-  it "should evaluate parent field" do
-    @e1.lazy_eval(:f2).should == 'f2'
+  it "should resolve parameters in preference to methods in the parent" do
+    @ev.lazy_eval(lambda { com }).should == 'PpC'
   end
 
-  it "should prefer parent param over parent field" do
-    @e1.lazy_eval(:common1).should == 'p2'
+  it "should have a parent" do
+    @ev.lazy_eval(lambda { parent }).should_not be_nil
   end
 
-  it "should prefer variable over parent param" do
-    @e1.lazy_eval(:common2).should == 'v1'
+  it "should not resolve #index" do
+    lambda { @ev.lazy_eval(lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
-describe BinData::LazyEvalEnv, "when nested" do
+describe BinData::LazyEvaluator, "with nested parents" do
   before(:each) do
-    @do4 = MockDataObject.new(:f4 => 'f4')
-    @do3 = MockDataObject.new(:f3 => 'f3')
-    @do2 = MockDataObject.new(:f2 => 'f2', :fs2 => :s3)
-    @do1 = MockDataObject.new(:f1 => 'f1')
+    pparent_methods = {:m1 => 'PPm1', :m2 => 'PPm2', :com => 'PPmC'}
+    pparent_params  = {:p1 => 'PPp1', :p2 => 'PPp2', :com => 'PPpC'}
+    pparent_obj = MockDataObject.new(pparent_methods, pparent_params)
+
+    parent_methods = {:m1 => 'Pm1', :com => 'PmC', :sym1 => :m2}
+    parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
+    parent_obj = MockDataObject.new(parent_methods, parent_params, pparent_obj)
+
+    methods = {:m1 => 'm1', :com => 'mC'}
+    params  = {:p1 => 'p1', :com => 'pC'}
+    obj = MockDataObject.new(methods, params, parent_obj)
 
-    @e4 = BinData::LazyEvalEnv.new
-    @e3 = BinData::LazyEvalEnv.new(@e4)
-    @e2 = BinData::LazyEvalEnv.new(@e3)
-    @e1 = BinData::LazyEvalEnv.new(@e2)
+    @ev = BinData::LazyEvaluator.new(obj)
+  end
 
-    @e4.data_object = @do4
-    @e3.data_object = @do3
-    @e2.data_object = @do2
-    @e1.data_object = @do1
+  it "should accept symbols as a shortcut to lambdas" do
+    @ev.lazy_eval(:p1).should == 'Pp1'
+    @ev.lazy_eval(:p2).should == 'PPp2'
+    @ev.lazy_eval(:m1).should == 'Pm1'
+    @ev.lazy_eval(:m2).should == 'PPm2'
+  end
 
-    @e4.params = {:p4 => 'p4', :s4 => 's4', :l4 => 'l4'}
-    @e3.params = {:p3 => 'p3', :s3 => :s4, :s4 => 'xx', :l3 => lambda { l4 }}
-    @e2.params = {:p2 => 'p2', :s2 => :s3, :l2 => lambda { l3 }}
+  it "should not resolve any unknown methods" do
+    lambda { @ev.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+  end
 
-    @e2.add_variable(:v2, 'v2')
+  it "should resolve parameters in the parent" do
+    @ev.lazy_eval(lambda { p1 }).should == 'Pp1'
   end
 
-  it "should access parent environments" do
-    @e1.lazy_eval(lambda { parent.p3 }).should == 'p3'
-    @e1.lazy_eval(lambda { parent.parent.p4 }).should == 'p4'
+  it "should resolve methods in the parent" do
+    @ev.lazy_eval(lambda { m1 }).should == 'Pm1'
   end
 
-  it "should cascade lambdas" do
-    @e1.lazy_eval(lambda { l2 }).should == 'l4'
-    @e1.lazy_eval(lambda { s2 }).should == 's4'
+  it "should resolve parameters in the parent's parent" do
+    @ev.lazy_eval(lambda { p2 }).should == 'PPp2'
   end
 
-  it "should access parent environments by cascading" do
-    @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'
+  it "should resolve methods in the parent's parent" do
+    @ev.lazy_eval(lambda { m2 }).should == 'PPm2'
+  end
+
+  it "should resolve parameters in preference to methods in the parent" do
+    @ev.lazy_eval(lambda { com }).should == 'PpC'
+  end
+
+  it "should resolve methods in the parent explicitly" do
+    @ev.lazy_eval(lambda { parent.m1 }).should == 'PPm1'
+  end
+
+  it "should cascade lambdas " do
+    @ev.lazy_eval(lambda { sym1 }).should == 'PPm2'
+  end
+
+  it "should not resolve #index" do
+    lambda { @ev.lazy_eval(lambda { index }) }.should raise_error(NoMethodError)
+  end
+end
+
+# This spec seems out of place, but :index is implemented in lazy.rb so this
+# is the best place for it.
+describe BinData::LazyEvaluator, "with BinData::Array" do
+  it "should use correct index" do
+    arr = BinData::Array.new(:type =>
+                               [:uint8, { :value => lambda { index * 10 } }],
+                             :initial_length => 3)
+    arr.snapshot.should == [0, 10, 20]
   end
 end