bindata 2.0.0 → 2.1.0

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/bindata/{deprecated.rb → warnings.rb}

@@ -3,12 +3,12 @@ module BinData
 
     # Don't override initialize.  If you are defining a new kind of datatype
     # (list, array, choice etc) then put your initialization code in
-    # #initialize_instance.  This is because BinData objects can be initialized
-    # as prototypes and your initialization code may not be called.
+    # #initialize_instance.  BinData objects might be initialized as prototypes
+    # and your initialization code may not be called.
     #
     # If you're subclassing BinData::Record, you are definitely doing the wrong
     # thing.  Read the documentation on how to use BinData.
-    # http://bindata.rubyforge.org/manual.html#records
+    # http://github.com/dmendel/bindata/wiki/Records
     alias_method :initialize_without_warning, :initialize
     def initialize_with_warning(*args)
       owner = method(:initialize).owner
@@ -29,5 +29,11 @@ module BinData
       end
     end
 
+    # #offset has been renamed to #abs_offset.
+    # Eventually #rel_offset will be renamed to #offset.
+    def offset
+      warn "#offset is deprecated in #{debug_name}. Use #abs_offset instead"
+      abs_offset
+    end
   end
 end

data/test/array_test.rb

@@ -168,7 +168,7 @@ describe BinData::Array, "with several elements" do
   end
 
   it "has correct offset" do
-    obj[2].offset.must_equal ExampleSingle.new.num_bytes * 2
+    obj[2].rel_offset.must_equal ExampleSingle.new.num_bytes * 2
   end
 
   it "has correct num_bytes" do
@@ -364,8 +364,8 @@ describe BinData::Array, "of bits" do
   end
 
   it "has correct offset" do
-    obj[7].offset.must_equal 0
-    obj[8].offset.must_equal 1
+    obj[7].rel_offset.must_equal 0
+    obj[8].rel_offset.must_equal 1
   end
 end
 

data/test/base_primitive_test.rb

@@ -170,40 +170,6 @@ describe BinData::BasePrimitive, "with :value" do
   end
 end
 
-describe BinData::BasePrimitive, "checking read value" do
-  let(:io) { ExampleSingle.io_with_value(12) }
-
-  describe ":check_value is non boolean" do
-    it "succeeds when check_value is correct" do
-      skip "deprecated"
-      data = ExampleSingle.new(:check_value => 12)
-      data.read(io)
-      data.value.must_equal 12
-    end
-
-    it "fails when check_value is incorrect" do
-      skip "deprecated"
-      data = ExampleSingle.new(:check_value => lambda { 99 })
-      lambda { data.read(io) }.must_raise BinData::ValidityError
-    end
-  end
-
-  describe ":check_value is boolean" do
-    it "succeeds when check_value is true" do
-      skip "deprecated"
-      data = ExampleSingle.new(:check_value => lambda { value < 20 })
-      data.read(io)
-      data.value.must_equal 12
-    end
-
-    it "fails when check_value is false" do
-      skip "deprecated"
-      data = ExampleSingle.new(:check_value => lambda { value > 20 })
-      lambda { data.read(io) }.must_raise BinData::ValidityError
-    end
-  end
-end
-
 describe BinData::BasePrimitive, "asserting value" do
   let(:io) { ExampleSingle.io_with_value(12) }
 

data/test/bits_test.rb

@@ -5,66 +5,58 @@ require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 module AllBitfields
 
   def test_has_a_sensible_value_of_zero
-    all_classes do |bit_class|
-      bit_class.new.must_equal 0
+    all_objects do |obj, nbits|
+      obj.must_equal 0
     end
   end
 
   def test_avoids_underflow
-    all_classes do |bit_class|
-      obj = bit_class.new
-
+    all_objects do |obj, nbits|
       obj.assign(min_value - 1)
       obj.must_equal min_value
     end
   end
 
   def test_avoids_overflow
-    all_classes do |bit_class|
-      obj = bit_class.new
-
+    all_objects do |obj, nbits|
       obj.assign(max_value + 1)
       obj.must_equal max_value
     end
   end
 
   def test_assign_values
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
         obj.assign(val)
-
         obj.must_equal val
       end
     end
   end
 
   def test_assign_values_from_other_bit_objects
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
-        obj.assign(bit_class.new(val))
-
+        obj.assign(obj.new(val))
         obj.must_equal val
       end
     end
   end
 
   def test_symmetrically_read_and_write
-    all_classes do |bit_class|
+    all_objects do |obj, nbits|
       some_values_within_range.each do |val|
-        obj = bit_class.new
         obj.assign(val)
-
-        obj.value_read_from_written.must_equal obj
+        other = obj.new
+        other.read(obj.to_binary_s)
+        other.must_equal obj
       end
     end
   end
 
-  def all_classes(&block)
-    @bits.each_pair do |bit_class, nbits|
+  def all_objects(&block)
+    @bits.each do |obj, nbits|
       @nbits = nbits
-      yield bit_class
+      yield obj, nbits
     end
   end
 
@@ -98,7 +90,7 @@ module AllBitfields
 end
 
 def generate_bit_classes_to_test(endian, signed)
-  bits = {}
+  bits = []
   if signed
     base  = "Sbit"
     start = 2
@@ -107,12 +99,20 @@ def generate_bit_classes_to_test(endian, signed)
     start = 1
   end
 
-  (start .. 50).each do |nbits|
+  (start .. 64).each do |nbits|
     name = "#{base}#{nbits}"
     name << "le" if endian == :little
-    bit_class = BinData.const_get(name)
-    bits[bit_class] = nbits
+    obj = BinData.const_get(name).new
+    bits << [obj, nbits]
+  end
+
+  (start .. 64).each do |nbits|
+    name = "#{base}"
+    name << "Le" if endian == :little
+    obj = BinData.const_get(name).new(:nbits => nbits)
+    bits << [obj, nbits]
   end
+
   bits
 end
 
@@ -125,11 +125,12 @@ describe "Unsigned big endian bitfields" do
   end
 
   it "read big endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1 << (nbits - 1)
+      obj.read(str)
+      obj.must_equal 1 << (nbits - 1)
     end
   end
 end
@@ -143,11 +144,12 @@ describe "Signed big endian bitfields" do
   end
 
   it "read big endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0100_0000].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1 << (nbits - 2)
+      obj.read(str)
+      obj.must_equal 1 << (nbits - 2)
     end
   end
 end
@@ -161,11 +163,12 @@ describe "Unsigned little endian bitfields" do
   end
 
   it "read little endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1
+      obj.read(str)
+      obj.must_equal 1
     end
   end
 end
@@ -179,11 +182,12 @@ describe "Signed little endian bitfields" do
   end
 
   it "read little endian values" do
-    @bits.each_pair do |bit_class, nbits|
+    all_objects do |obj, nbits|
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).must_equal 1
+      obj.read(str)
+      obj.must_equal 1
     end
   end
 end

data/test/common.rb

@@ -1,4 +1,8 @@
 require 'rubygems'
+
+require 'coveralls'
+Coveralls.wear!
+
 require 'minitest/autorun'
 require 'stringio'
 

data/test/io_test.rb

@@ -152,6 +152,21 @@ describe BinData::IO::Write, "when writing" do
     stream.value.must_equal "abcd"
   end
 
+  it "has #offset" do
+    io.offset.must_equal 0
+
+    io.writebytes("abcd")
+    io.offset.must_equal 4
+
+    io.writebytes("ABCD")
+    io.offset.must_equal 8
+  end
+
+  it "rounds up #offset when writing bits" do
+    io.writebits(123, 9, :little)
+    io.offset.must_equal 2
+  end
+
   it "flushes" do
     io.writebytes("abcd")
     io.flush

data/test/lazy_test.rb

@@ -73,12 +73,16 @@ end
 
 describe BinData::LazyEvaluator, "with one parent" do
   subject {
-    parent_methods = {:m1 => 'Pm1', :com1 => 'PmC', :mm => 3}
+    parent_methods = {:m1 => 'Pm1', :m2 => 'Pm2', :com1 => 'PmC', :mm => 3}
     parent_params  = {:p1 => 'Pp1', :com1 => 'PpC'}
     parent_obj = MockBinDataObject.new(parent_methods, parent_params)
 
-    def parent_obj.echo(a1, a2)
-      [a1, a2]
+    class << parent_obj
+      def echo(a1, a2)
+        [a1, a2]
+      end
+
+      private :m2
     end
 
     methods = {:m1 => 'm1', :com1 => 'mC'}
@@ -118,6 +122,10 @@ describe BinData::LazyEvaluator, "with one parent" do
     lazy_eval(lambda { echo(p1, m1) }).must_equal ['Pp1', 'Pm1']
   end
 
+  it "invokes private methods in the parent" do
+    lazy_eval(lambda { m2 }).must_equal 'Pm2'
+  end
+
   it "resolves parameters in preference to methods in the parent" do
     lazy_eval(lambda { com1 }).must_equal 'PpC'
   end

data/test/record_test.rb

@@ -241,12 +241,12 @@ describe BinData::Record, "with nested structs" do
     obj.c.y.must_equal 3
   end
 
-  it "returns correct offset" do
-    obj.offset.must_equal 0
-    obj.b.offset.must_equal 1
-    obj.b.w.offset.must_equal 1
-    obj.c.offset.must_equal 3
-    obj.c.z.offset.must_equal 4
+  it "returns correct abs_offset" do
+    obj.abs_offset.must_equal 0
+    obj.b.abs_offset.must_equal 1
+    obj.b.w.abs_offset.must_equal 1
+    obj.c.abs_offset.must_equal 3
+    obj.c.z.abs_offset.must_equal 4
   end
 
   it "returns correct rel_offset" do
@@ -378,6 +378,77 @@ describe BinData::Record, "with an endian defined" do
   end
 end
 
+describe BinData::Record, "with endian :big_and_little" do
+  class RecordWithBnLEndian < BinData::Record
+    endian :big_and_little
+    int16 :a, :value => 1
+  end
+
+  it "is not registered" do
+    lambda {
+      BinData::RegisteredClasses.lookup("RecordWithBnLEndian")
+    }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "creates big endian version" do
+    obj = RecordWithBnLEndianBe.new
+    obj.to_binary_s.must_equal binary("\x00\x01")
+  end
+
+  it "creates little endian version" do
+    obj = RecordWithBnLEndianLe.new
+    obj.to_binary_s.must_equal binary("\x01\x00")
+  end
+
+  it "requires :endian as argument" do
+    lambda {
+      RecordWithBnLEndian.new
+    }.must_raise ArgumentError
+  end
+
+  it "accepts :endian as argument" do
+    obj = RecordWithBnLEndian.new(:endian => :little)
+    obj.to_binary_s.must_equal binary("\x01\x00")
+  end
+end
+
+describe BinData::Record, "with endian :big_and_little when subclassed" do
+  class ARecordWithBnLEndian < BinData::Record
+    endian :big_and_little
+    int16 :a, :value => 1
+  end
+  class BRecordWithBnLEndian < ARecordWithBnLEndian
+    int16 :b, :value => 2
+  end
+
+  it "is not registered" do
+    lambda {
+      BinData::RegisteredClasses.lookup("BRecordWithBnLEndian")
+    }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "creates big endian version" do
+    obj = BRecordWithBnLEndianBe.new
+    obj.to_binary_s.must_equal binary("\x00\x01\x00\x02")
+  end
+
+  it "creates little endian version" do
+    obj = BRecordWithBnLEndianLe.new
+    obj.to_binary_s.must_equal binary("\x01\x00\x02\x00")
+  end
+
+  it "requires :endian as argument" do
+    lambda {
+      BRecordWithBnLEndian.new
+    }.must_raise ArgumentError
+  end
+
+  it "accepts :endian as argument" do
+    obj = BRecordWithBnLEndian.new(:endian => :little)
+    obj.to_binary_s.must_equal binary("\x01\x00\x02\x00")
+  end
+end
+
 describe BinData::Record, "defined recursively" do
   class RecursiveRecord < BinData::Record
     endian  :big
@@ -476,6 +547,12 @@ describe BinData::Record, "with :onlyif" do
     obj.to_binary_s.must_equal "\x03\x05"
   end
 
+  it "identifies if fields are included" do
+    obj.a?.must_equal true
+    obj.b?.must_equal true
+    obj.c?.must_equal false
+  end
+
   it "reads as lambdaed" do
     obj.read("\x01\x02")
     obj.snapshot.must_equal({:a => 1, :c => 2})

data/test/struct_test.rb

@@ -250,11 +250,11 @@ describe BinData::Struct, "with nested structs" do
     obj.c.z.must_equal 0
   end
 
-  it "returns correct offset" do
-    obj.b.offset.must_equal 1
-    obj.b.w.offset.must_equal 1
-    obj.c.offset.must_equal 3
-    obj.c.z.offset.must_equal 4
+  it "returns correct abs_offset" do
+    obj.b.abs_offset.must_equal 1
+    obj.b.w.abs_offset.must_equal 1
+    obj.c.abs_offset.must_equal 3
+    obj.c.z.abs_offset.must_equal 4
   end
 end
 
@@ -313,10 +313,10 @@ describe BinData::Struct, "with bit fields" do
   end
 
   it "has correct offsets" do
-    obj.a.offset.must_equal 0
-    obj.b.offset.must_equal 0
-    obj.c.offset.must_equal 1
-    obj.d.offset.must_equal 2
+    obj.a.rel_offset.must_equal 0
+    obj.b.rel_offset.must_equal 0
+    obj.c.rel_offset.must_equal 1
+    obj.d.rel_offset.must_equal 2
   end
 end
 
@@ -338,6 +338,37 @@ describe BinData::Struct, "with nested endian" do
   end
 end
 
+describe BinData::Struct, "with byte_align" do
+  let(:obj) {
+    params = { :fields => [[:int8, :a],
+                           [:int8, :b, :byte_align => 5],
+                           [:bit2, :c],
+                           [:int8, :d, :byte_align => 3]] }
+    BinData::Struct.new(params)
+  }
+
+  it "has #num_bytes" do
+    obj.num_bytes.must_equal 10
+  end
+
+  it "reads" do
+    obj.read("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
+    obj.snapshot.must_equal({ :a => 1, :b => 2, :c => 3, :d => 4 })
+  end
+
+  it "writes" do
+    obj.assign(:a => 1, :b => 2, :c => 3, :d => 4)
+    obj.to_binary_s.must_equal binary("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
+  end
+
+  it "has correct offsets" do
+    obj.a.rel_offset.must_equal 0
+    obj.b.rel_offset.must_equal 5
+    obj.c.rel_offset.must_equal 6
+    obj.d.rel_offset.must_equal 9
+  end
+end
+
 describe BinData::Struct, "with dynamically named types" do
   it "instantiates" do
     dyn = BinData::Struct.new(:name => :my_struct, :fields => [[:int8, :a, {:initial_value => 3}]])