bindata 0.9.3 → 0.10.0

data/spec/io_spec.rb

@@ -39,6 +39,13 @@ describe BinData::IO do
     io.readbytes(4).should == "cdef"
   end
 
+  it "should read all bytes" do
+    stream = StringIO.new("abcdefghij")
+    io = BinData::IO.new(stream)
+
+    io.read_all_bytes.should == "abcdefghij"
+  end
+
   it "should raise error when reading at eof" do
     stream = StringIO.new("abcdefghij")
     io = BinData::IO.new(stream)
@@ -64,6 +71,17 @@ describe BinData::IO do
     stream.rewind
     stream.read.should == "abcd"
   end
+
+  it "should flush" do
+    stream = StringIO.new
+    io = BinData::IO.new(stream)
+    io.writebytes("abcd")
+    io.flush
+
+    stream.rewind
+    stream.read.should == "abcd"
+  end
+
 end
 
 describe BinData::IO, "reading bits in big endian" do
@@ -76,36 +94,36 @@ describe BinData::IO, "reading bits in big endian" do
   end
 
   it "should read a bitfield less than 1 byte" do
-    @io.readbits(3).should == 0b111
+    @io.readbits(3, :big).should == 0b111
   end
 
   it "should read a bitfield more than 1 byte" do
-    @io.readbits(10).should == 0b1111_1010_11
+    @io.readbits(10, :big).should == 0b1111_1010_11
   end
 
   it "should read a bitfield more than 2 bytes" do
-    @io.readbits(17).should == 0b1111_1010_1100_1110_0
+    @io.readbits(17, :big).should == 0b1111_1010_1100_1110_0
   end
 
   it "should read two bitfields totalling less than 1 byte" do
-    @io.readbits(5).should == 0b1111_1
-    @io.readbits(2).should == 0b01
+    @io.readbits(5, :big).should == 0b1111_1
+    @io.readbits(2, :big).should == 0b01
   end
 
   it "should read two bitfields totalling more than 1 byte" do
-    @io.readbits(6).should == 0b1111_10
-    @io.readbits(8).should == 0b10_1100_11
+    @io.readbits(6, :big).should == 0b1111_10
+    @io.readbits(8, :big).should == 0b10_1100_11
   end
 
   it "should read two bitfields totalling more than 2 bytes" do
-    @io.readbits(7).should == 0b1111_101
-    @io.readbits(12).should == 0b0_1100_1110_011
+    @io.readbits(7, :big).should == 0b1111_101
+    @io.readbits(12, :big).should == 0b0_1100_1110_011
   end
 
   it "should ignore unused bits when reading bytes" do
-    @io.readbits(3).should == 0b111
+    @io.readbits(3, :big).should == 0b111
     @io.readbytes(1).should == [@b2].pack("C")
-    @io.readbits(2).should == 0b01
+    @io.readbits(2, :big).should == 0b01
   end
 end
 
@@ -158,7 +176,7 @@ class BitWriterHelper
     @io = BinData::IO.new(@stringio)
   end
 
-  def writebits(val, nbits, endian = :big)
+  def writebits(val, nbits, endian)
     @io.writebits(val, nbits, endian)
   end
 
@@ -179,42 +197,42 @@ describe BinData::IO, "writing bits in big endian" do
   end
 
   it "should write a bitfield less than 1 byte" do
-    @io.writebits(0b010, 3)
+    @io.writebits(0b010, 3, :big)
     @io.value.should == [0b0100_0000].pack("C")
   end
 
   it "should write a bitfield more than 1 byte" do
-    @io.writebits(0b10_1001_1101, 10)
+    @io.writebits(0b10_1001_1101, 10, :big)
     @io.value.should == [0b1010_0111, 0b0100_0000].pack("CC")
   end
 
   it "should write a bitfield more than 2 bytes" do
-    @io.writebits(0b101_1000_0010_1001_1101, 19)
+    @io.writebits(0b101_1000_0010_1001_1101, 19, :big)
     @io.value.should == [0b1011_0000, 0b0101_0011, 0b1010_0000].pack("CCC")
   end
 
   it "should write two bitfields totalling less than 1 byte" do
-    @io.writebits(0b1_1001, 5)
-    @io.writebits(0b00, 2)
+    @io.writebits(0b1_1001, 5, :big)
+    @io.writebits(0b00, 2, :big)
     @io.value.should == [0b1100_1000].pack("C")
   end
 
   it "should write two bitfields totalling more than 1 byte" do
-    @io.writebits(0b01_0101, 6)
-    @io.writebits(0b001_1001, 7)
+    @io.writebits(0b01_0101, 6, :big)
+    @io.writebits(0b001_1001, 7, :big)
     @io.value.should == [0b0101_0100, 0b1100_1000].pack("CC")
   end
 
   it "should write two bitfields totalling more than 2 bytes" do
-    @io.writebits(0b01_0111, 6)
-    @io.writebits(0b1_0010_1001_1001, 13)
+    @io.writebits(0b01_0111, 6, :big)
+    @io.writebits(0b1_0010_1001_1001, 13, :big)
     @io.value.should == [0b0101_1110, 0b0101_0011, 0b0010_0000].pack("CCC")
   end
 
   it "should pad unused bits when writing bytes" do
-    @io.writebits(0b101, 3)
+    @io.writebits(0b101, 3, :big)
     @io.writebytes([0b1011_1111].pack("C"))
-    @io.writebits(0b01, 2)
+    @io.writebits(0b01, 2, :big)
 
     @io.value.should == [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
   end
@@ -285,4 +303,3 @@ describe BinData::IO, "with changing endian" do
     io.value.should == [0b1100_0000, 0b0000_0010].pack("CC")
   end
 end
-

data/spec/lazy_spec.rb

@@ -1,8 +1,6 @@
 #!/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.
@@ -15,33 +13,51 @@ class MockDataObject
     @parameters = params
     @parent = parent
   end
-  attr_accessor :parent, :parameters
+  attr_accessor :parent
+
+  def has_parameter?(k)
+    @parameters.has_key?(k)
+  end
+
+  def get_parameter(k)
+    @parameters[k]
+  end
 end
 
+# Shortcut to save typing
+LE = BinData::LazyEvaluator
+
 describe BinData::LazyEvaluator, "with no parents" do
   before(:each) do
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    obj = MockDataObject.new(methods, params)
-    @ev = BinData::LazyEvaluator.new(obj)
+    @obj = MockDataObject.new(methods, params)
+  end
+
+  it "should evaluate raw value" do
+    LE.eval(@obj, 5).should == 5
+  end
+
+  it "should evaluate value" do
+    LE.eval(@obj, lambda { 5 }).should == 5
   end
 
   it "should evaluate overrides" do
-    @ev.lazy_eval(lambda { o1 }, :o1 => 'o1').should == 'o1'
+    LE.eval(@obj, lambda { o1 }, :o1 => 'o1').should == 'o1'
   end
 
   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)
+    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(@obj, lambda { m1 }) }.should raise_error(NameError)
+    lambda { LE.eval(@obj, lambda { p1 }) }.should raise_error(NameError)
   end
 
   it "should not have a parent" do
-    @ev.lazy_eval(lambda { parent }).should be_nil
+    LE.eval(@obj, lambda { parent }).should be_nil
   end
 
   it "should not resolve #index" do
-    lambda { @ev.lazy_eval(lambda { index }) }.should raise_error(NoMethodError)
+    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
@@ -51,39 +67,57 @@ describe BinData::LazyEvaluator, "with one parent" do
     parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
     parent_obj = MockDataObject.new(parent_methods, parent_params)
 
+    def parent_obj.echo(a1, a2)
+      [a1, a2]
+    end
+
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    obj = MockDataObject.new(methods, params, parent_obj)
+    @obj = MockDataObject.new(methods, params, parent_obj)
+  end
 
-    @ev = BinData::LazyEvaluator.new(obj)
+  it "should evaluate raw value" do
+    LE.eval(@obj, 5).should == 5
   end
 
-  it "should evaluate overrides" do
-    @ev.lazy_eval(lambda { p1 }, :p1 => 'o1').should == 'o1'
+  it "should evaluate value" do
+    LE.eval(@obj, lambda { 5 }).should == 5
+  end
+
+  it "should evaluate overrides before params" do
+    LE.eval(@obj, lambda { p1 }, :p1 => 'o1').should == 'o1'
+  end
+
+  it "should evaluate overrides before methods" do
+    LE.eval(@obj, lambda { m1 }, :m1 => 'o1').should == 'o1'
   end
 
   it "should not resolve any unknown methods" do
-    lambda { @ev.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
   end
 
   it "should resolve parameters in the parent" do
-    @ev.lazy_eval(lambda { p1 }).should == 'Pp1'
+    LE.eval(@obj, lambda { p1 }).should == 'Pp1'
   end
 
   it "should resolve methods in the parent" do
-    @ev.lazy_eval(lambda { m1 }).should == 'Pm1'
+    LE.eval(@obj, lambda { m1 }).should == 'Pm1'
+  end
+
+  it "should invoke methods in the parent" do
+    LE.eval(@obj, lambda { echo(p1, m1) }).should == ['Pp1', 'Pm1']
   end
 
   it "should resolve parameters in preference to methods in the parent" do
-    @ev.lazy_eval(lambda { com }).should == 'PpC'
+    LE.eval(@obj, lambda { com }).should == 'PpC'
   end
 
   it "should have a parent" do
-    @ev.lazy_eval(lambda { parent }).should_not be_nil
+    LE.eval(@obj, lambda { parent }).should_not be_nil
   end
 
   it "should not resolve #index" do
-    lambda { @ev.lazy_eval(lambda { index }) }.should raise_error(NoMethodError)
+    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end
 
@@ -93,68 +127,80 @@ describe BinData::LazyEvaluator, "with nested parents" do
     pparent_params  = {:p1 => 'PPp1', :p2 => 'PPp2', :com => 'PPpC'}
     pparent_obj = MockDataObject.new(pparent_methods, pparent_params)
 
-    parent_methods = {:m1 => 'Pm1', :com => 'PmC', :sym1 => :m2}
+    def pparent_obj.echo(arg)
+      ["PP", arg]
+    end
+
+    def pparent_obj.echo2(arg)
+      ["PP2", arg]
+    end
+
+    parent_methods = {:m1 => 'Pm1', :com => 'PmC', :sym1 => :m2, :sym2 => lambda { m2 }}
     parent_params  = {:p1 => 'Pp1', :com => 'PpC'}
     parent_obj = MockDataObject.new(parent_methods, parent_params, pparent_obj)
 
+    def parent_obj.echo(arg)
+      ["P", arg]
+    end
+
     methods = {:m1 => 'm1', :com => 'mC'}
     params  = {:p1 => 'p1', :com => 'pC'}
-    obj = MockDataObject.new(methods, params, parent_obj)
-
-    @ev = BinData::LazyEvaluator.new(obj)
+    @obj = MockDataObject.new(methods, params, parent_obj)
   end
 
   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'
+    LE.eval(@obj, :p1).should == 'Pp1'
+    LE.eval(@obj, :p2).should == 'PPp2'
+    LE.eval(@obj, :m1).should == 'Pm1'
+    LE.eval(@obj, :m2).should == 'PPm2'
   end
 
   it "should not resolve any unknown methods" do
-    lambda { @ev.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+    lambda { LE.eval(@obj, lambda { unknown }) }.should raise_error(NameError)
   end
 
   it "should resolve parameters in the parent" do
-    @ev.lazy_eval(lambda { p1 }).should == 'Pp1'
+    LE.eval(@obj, lambda { p1 }).should == 'Pp1'
   end
 
   it "should resolve methods in the parent" do
-    @ev.lazy_eval(lambda { m1 }).should == 'Pm1'
+    LE.eval(@obj, lambda { m1 }).should == 'Pm1'
   end
 
   it "should resolve parameters in the parent's parent" do
-    @ev.lazy_eval(lambda { p2 }).should == 'PPp2'
+    LE.eval(@obj, lambda { p2 }).should == 'PPp2'
   end
 
   it "should resolve methods in the parent's parent" do
-    @ev.lazy_eval(lambda { m2 }).should == 'PPm2'
+    LE.eval(@obj, lambda { m2 }).should == 'PPm2'
+  end
+
+  it "should invoke methods in the parent" do
+    LE.eval(@obj, lambda { echo(m1) }).should == ['P', 'Pm1']
+  end
+
+  it "should invoke methods in the parent's parent" do
+    LE.eval(@obj, lambda { parent.echo(m1) }, { :m1 => 'o1'}).should == ['PP', 'o1']
+  end
+
+  it "should invoke methods in the parent's parent" do
+    LE.eval(@obj, lambda { echo2(m1) }).should == ['PP2', 'Pm1']
   end
 
   it "should resolve parameters in preference to methods in the parent" do
-    @ev.lazy_eval(lambda { com }).should == 'PpC'
+    LE.eval(@obj, lambda { com }).should == 'PpC'
   end
 
   it "should resolve methods in the parent explicitly" do
-    @ev.lazy_eval(lambda { parent.m1 }).should == 'PPm1'
+    LE.eval(@obj, lambda { parent.m1 }).should == 'PPm1'
   end
 
   it "should cascade lambdas " do
-    @ev.lazy_eval(lambda { sym1 }).should == 'PPm2'
+    LE.eval(@obj, lambda { sym1 }).should == 'PPm2'
+    LE.eval(@obj, lambda { sym2 }).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]
+    lambda { LE.eval(@obj, lambda { index }) }.should raise_error(NoMethodError)
   end
 end

data/spec/primitive_spec.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata'
+
+describe BinData::Primitive, "when subclassing" do
+  before(:all) do
+    eval <<-END
+      class SubClassOfPrimitive < BinData::Primitive
+        expose_methods_for_testing
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = SubClassOfPrimitive.new
+  end
+
+  it "should raise errors on unimplemented methods" do
+    lambda { @obj.set(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj.get }.should raise_error(NotImplementedError)
+  end
+end
+
+describe BinData::Primitive, "when defining" do
+  it "should allow inheriting from deprecated SingleValue" do
+    lambda {
+      eval <<-END
+        class SubclassSingleValue < BinData::SingleValue
+        end
+      END
+    }.should_not raise_error
+  end
+
+  it "should fail on non registered types" do
+    lambda {
+      eval <<-END
+        class BadTypePrimitive < BinData::Primitive
+          non_registered_type :a
+        end
+      END
+    }.should raise_error(TypeError)
+  end
+
+  it "should fail on duplicate names" do
+    lambda {
+      eval <<-END
+        class DuplicateNamePrimitive < BinData::Primitive
+          int8 :a
+          int8 :b
+          int8 :a
+        end
+      END
+    }.should raise_error(SyntaxError)
+  end
+
+  it "should fail when field name shadows an existing method" do
+    lambda {
+      eval <<-END
+        class ExistingNamePrimitive < BinData::Primitive
+          int8 :object_id
+        end
+      END
+    }.should raise_error(NameError)
+  end
+
+  it "should fail on unknown endian" do
+    lambda {
+      eval <<-END
+        class BadEndianPrimitive < BinData::Primitive
+          endian 'a bad value'
+        end
+      END
+    }.should raise_error(ArgumentError)
+  end
+end
+
+describe BinData::Primitive do
+  before(:all) do
+    eval <<-END
+      class PrimitiveWithEndian < BinData::Primitive
+        endian :little
+        int16 :a
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = PrimitiveWithEndian.new
+  end
+
+  it "should support endian" do
+    @obj.value = 5
+    @obj.to_binary_s.should == "\x05\x00"
+  end
+
+  it "should set value" do
+    @obj.value = 5
+    @obj.to_binary_s.should == "\x05\x00"
+  end
+
+  it "should read value" do
+    @obj.read("\x00\x01")
+    @obj.value.should == 0x100
+  end
+
+  it "should accept standard parameters" do
+    obj = PrimitiveWithEndian.new(:initial_value => 2)
+    obj.to_binary_s.should == "\x02\x00"
+  end
+
+  it "should return num_bytes" do
+    @obj.num_bytes.should == 2
+  end
+
+  it "should raise error on missing methods" do
+    lambda {
+      @obj.does_not_exist
+    }.should raise_error(NoMethodError)
+  end
+end
+
+describe BinData::Primitive, "requiring custom parameters" do
+  before(:all) do
+    eval <<-END
+      class PrimitiveWithCustom < BinData::Primitive
+        int8 :a, :initial_value => :iv
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  it "should pass parameters correctly" do
+    obj = PrimitiveWithCustom.new(:iv => 5)
+    obj.value.should == 5
+  end
+end
+
+describe BinData::Primitive, "with custom mandatory parameters" do
+  before(:all) do
+    eval <<-END
+      class MandatoryPrimitive < BinData::Primitive
+        mandatory_parameter :arg1
+
+        uint8 :a, :value => :arg1
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  it "should raise error if mandatory parameter is not supplied" do
+    lambda { MandatoryPrimitive.new }.should raise_error(ArgumentError)
+  end
+
+  it "should use mandatory parameter" do
+    obj = MandatoryPrimitive.new(:arg1 => 5)
+    obj.value.should == 5
+  end
+end
+
+describe BinData::Primitive, "with custom default parameters" do
+  before(:all) do
+    eval <<-END
+      class DefaultPrimitive < BinData::Primitive
+        default_parameter :arg1 => 5
+
+        uint8 :a, :value => :arg1
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  it "should not raise error if default parameter is not supplied" do
+    lambda { DefaultPrimitive.new }.should_not raise_error(ArgumentError)
+  end
+
+  it "should use default parameter" do
+    obj = DefaultPrimitive.new
+    obj.value.should == 5
+  end
+
+  it "should be able to override default parameter" do
+    obj = DefaultPrimitive.new(:arg1 => 7)
+    obj.value.should == 7
+  end
+end