bindata 0.9.0 → 0.9.1

data/spec/array_spec.rb

@@ -2,6 +2,7 @@
 
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/array'
+require 'bindata/bits'
 require 'bindata/int'
 require 'bindata/struct'
 
@@ -266,3 +267,39 @@ describe BinData::Array, "with :read_until containing +array+ and +index+" do
     @data.length.should == 7
   end
 end
+
+describe BinData::Array, "of bits" do
+  before(:each) do
+    @data = BinData::Array.new(:type => :bit1, :initial_length => 15)
+  end
+
+  it "should read" do
+    str = [0b0001_0100, 0b1000_1000].pack("CC")
+    @data.read(str)
+    @data[0].should  == 0
+    @data[1].should  == 0
+    @data[2].should  == 0
+    @data[3].should  == 1
+    @data[4].should  == 0
+    @data[5].should  == 1
+    @data[6].should  == 0
+    @data[7].should  == 0
+    @data[8].should  == 1
+    @data[9].should  == 0
+    @data[10].should == 0
+    @data[11].should == 0
+    @data[12].should == 1
+    @data[13].should == 0
+    @data[14].should == 0
+  end
+
+  it "should write" do
+    @data[3] = 1
+    @data.to_s.should == [0b0001_0000, 0b0000_0000].pack("CC")
+  end
+
+  it "should return num_bytes" do
+    @data.num_bytes.should == 2
+  end
+end
+

data/spec/base_spec.rb

@@ -5,13 +5,13 @@ require 'bindata/base'
 
 class BaseStub < BinData::Base
   def clear; end
-  def _do_read(io) end
-  def done_read; end
-  def _write(io) end
-  def _num_bytes; end
-  def snapshot; 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
 end
 
 describe BinData::Base, "with mandatory parameters" do
@@ -142,7 +142,7 @@ describe BinData::Base, "with :check_offset" do
       class TenByteOffsetBase < BaseStub
         def do_read(io)
           # advance the io position before checking offset
-          io.seek(10, IO::SEEK_CUR)
+          io.seekbytes(10)
           super(io)
         end
       end
@@ -184,7 +184,7 @@ describe BinData::Base, "with :adjust_offset" do
       class TenByteAdjustingOffsetBase < BaseStub
         def do_read(io)
           # advance the io position before checking offset
-          io.seek(10, IO::SEEK_CUR)
+          io.seekbytes(10)
           super(io)
         end
       end
@@ -226,8 +226,8 @@ describe BinData::Base, "with :readwrite => false" do
       class NoIOBase < BaseStub
         attr_accessor :mock
         def _do_read(io) mock._do_read(io); end
-        def _write(io) mock._write(io); end
-        def _num_bytes; mock._num_bytes; end
+        def _do_write(io) mock._do_write(io); end
+        def _do_num_bytes; mock._do_num_bytes; end
       end
     END
   end
@@ -250,16 +250,33 @@ describe BinData::Base, "with :readwrite => false" do
   end
 
   it "should have zero num_bytes" do
-    @obj.mock.should_not_receive(:_num_bytes)
+    @obj.mock.should_not_receive(:_do_num_bytes)
     @obj.num_bytes.should be_zero
   end
 end
 
+describe BinData::Base, "with :onlyif" do
+  before(:all) do
+    eval <<-END
+      class OnlyIfBase < 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"
+  end
+end
+
 describe BinData::Base, "when subclassing" do
   before(:all) do
     eval <<-END
       class SubClassOfBase < BinData::Base
-        public :_do_read, :_write, :_num_bytes
+        public :_do_read, :_do_write, :_do_num_bytes
       end
     END
   end
@@ -273,13 +290,13 @@ describe BinData::Base, "when subclassing" do
       SubClassOfBase.all_possible_field_names(nil)
     }.should raise_error(NotImplementedError)
     lambda { @obj.clear }.should raise_error(NotImplementedError)
-    lambda { @obj._do_read(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj.done_read }.should raise_error(NotImplementedError)
-    lambda { @obj._write(nil) }.should raise_error(NotImplementedError)
-    lambda { @obj._num_bytes }.should raise_error(NotImplementedError)
-    lambda { @obj.snapshot }.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)
   end
 end
 
@@ -323,7 +340,7 @@ describe BinData::Base do
     eval <<-END
       class InstanceOfBase < BaseStub
         def snapshot; 123; end
-        def _write(io); io.write('456'); end
+        def _do_write(io); io.writebytes('456'); end
       end
     END
   end

data/spec/bits_spec.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/bits'
+
+describe "Bits of size 1" do
+  it "should accept true as value" do
+    obj = BinData::Bit1.new
+    obj.value = true
+    obj.value.should == 1
+
+    obj = BinData::Bit1le.new
+    obj.value = true
+    obj.value.should == 1
+  end
+
+  it "should accept false as value" do
+    obj = BinData::Bit1.new
+    obj.value = false
+    obj.value.should == 0
+
+    obj = BinData::Bit1le.new
+    obj.value = false
+    obj.value.should == 0
+  end
+
+  it "should accept nil as value" do
+    obj = BinData::Bit1.new
+    obj.value = nil
+    obj.value.should == 0
+
+    obj = BinData::Bit1le.new
+    obj.value = nil
+    obj.value.should == 0
+  end
+end
+
+describe "All bitfields" do
+  it "should have a sensible value of zero" do
+    begin
+      nbits = 1
+      loop do
+        ["", "le"].each do |suffix|
+          klass = BinData.const_get("Bit#{nbits}#{suffix}")
+          klass.new.value.should be_zero
+        end
+
+        nbits += 1
+      end
+    rescue NameError
+    end
+  end
+
+  it "should clamp " do
+    begin
+      nbits = 1
+      loop do
+        ["", "le"].each do |suffix|
+          klass = BinData.const_get("Bit#{nbits}#{suffix}")
+          obj = klass.new
+
+          obj.value = -1
+          obj.value.should == 0
+
+          obj.value = 1 << nbits
+          obj.value.should == ((1 << nbits) - 1)
+        end
+
+        nbits += 1
+      end
+    rescue NameError
+    end
+  end
+
+  it "should read big endian value" do
+    begin
+      nbits = 1
+      loop do
+        klass = BinData.const_get("Bit#{nbits}")
+        obj = klass.new
+
+        str = [0b1000_0000].pack("C") + "\000" * (nbits / 8)
+        obj.read(str)
+        obj.value.should == 1 << (nbits - 1)
+
+        nbits += 1
+      end
+    rescue NameError
+    end
+  end
+
+  it "should read little endian value" do
+    begin
+      nbits = 1
+      loop do
+        klass = BinData.const_get("Bit#{nbits}le")
+        obj = klass.new
+
+        str = [0b0000_0001].pack("C") + "\000" * (nbits / 8)
+        obj.read(str)
+        obj.value.should == 1
+
+        nbits += 1
+      end
+    rescue NameError
+    end
+  end
+
+  it "should read written values" do
+    begin
+      nbits = 1
+      loop do
+        ["", "le"].each do |suffix|
+          klass = BinData.const_get("Bit#{nbits}#{suffix}")
+
+          min = 0
+          max = (1 << nbits) - 1
+          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|
+            obj = klass.new
+            obj.value = val
+            str = obj.to_s
+            obj.read(str)
+            obj.value.should == val
+          end
+        end
+
+        nbits += 1
+      end
+    rescue NameError
+    end
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,288 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/io'
+
+describe BinData::IO do
+  it "should wrap strings in StringIO" do
+    io = BinData::IO.new("abcd")
+    io.raw_io.class.should == StringIO
+  end
+
+  it "should not wrap IO objects" do
+    stream = StringIO.new
+    io = BinData::IO.new(stream)
+    io.raw_io.should == stream
+  end
+
+  it "should raise error when io is BinData::IO" do
+    lambda {
+      io = BinData::IO.new(BinData::IO.new(""))
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should return correct offset" do
+    stream = StringIO.new("abcdefghij")
+    stream.seek(3, IO::SEEK_CUR)
+
+    io = BinData::IO.new(stream)
+    io.offset.should == 0
+    io.readbytes(4)
+    io.offset.should == 4
+  end
+
+  it "should seek" do
+    stream = StringIO.new("abcdefghij")
+    io = BinData::IO.new(stream)
+
+    io.seekbytes(2)
+    io.readbytes(4).should == "cdef"
+  end
+
+  it "should raise error when reading at eof" do
+    stream = StringIO.new("abcdefghij")
+    io = BinData::IO.new(stream)
+    io.seekbytes(10)
+    lambda {
+      io.readbytes(3)
+    }.should raise_error(EOFError)
+  end
+
+  it "should raise error on short reads" do
+    stream = StringIO.new("abcdefghij")
+    io = BinData::IO.new(stream)
+    lambda {
+      io.readbytes(20)
+    }.should raise_error(IOError)
+  end
+
+  it "should write" do
+    stream = StringIO.new
+    io = BinData::IO.new(stream)
+    io.writebytes("abcd")
+
+    stream.rewind
+    stream.read.should == "abcd"
+  end
+end
+
+describe BinData::IO, "reading bits in big endian" do
+  before(:each) do
+    @b1 = 0b1111_1010
+    @b2 = 0b1100_1110
+    @b3 = 0b0110_1010
+    str = [@b1, @b2, @b3].pack("CCC")
+    @io = BinData::IO.new(str)
+  end
+
+  it "should read a bitfield less than 1 byte" do
+    @io.readbits(3).should == 0b111
+  end
+
+  it "should read a bitfield more than 1 byte" do
+    @io.readbits(10).should == 0b1111_1010_11
+  end
+
+  it "should read a bitfield more than 2 bytes" do
+    @io.readbits(17).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
+  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
+  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
+  end
+
+  it "should ignore unused bits when reading bytes" do
+    @io.readbits(3).should == 0b111
+    @io.readbytes(1).should == [@b2].pack("C")
+    @io.readbits(2).should == 0b01
+  end
+end
+
+describe BinData::IO, "reading bits in little endian" do
+  before(:each) do
+    @b1 = 0b1111_1010
+    @b2 = 0b1100_1110
+    @b3 = 0b0110_1010
+    str = [@b1, @b2, @b3].pack("CCC")
+    @io = BinData::IO.new(str)
+  end
+
+  it "should read a bitfield less than 1 byte" do
+    @io.readbits(3, :little).should == 0b010
+  end
+
+  it "should read a bitfield more than 1 byte" do
+    @io.readbits(10, :little).should == 0b10_1111_1010
+  end
+
+  it "should read a bitfield more than 2 bytes" do
+    @io.readbits(17, :little).should == 0b0_1100_1110_1111_1010
+  end
+
+  it "should read two bitfields totalling less than 1 byte" do
+    @io.readbits(5, :little).should == 0b1_1010
+    @io.readbits(2, :little).should == 0b11
+  end
+
+  it "should read two bitfields totalling more than 1 byte" do
+    @io.readbits(6, :little).should == 0b11_1010
+    @io.readbits(8, :little).should == 0b00_1110_11
+  end
+
+  it "should read two bitfields totalling more than 2 bytes" do
+    @io.readbits(7, :little).should == 0b111_1010
+    @io.readbits(12, :little).should == 0b010_1100_1110_1
+  end
+
+  it "should ignore unused bits when reading bytes" do
+    @io.readbits(3, :little).should == 0b010
+    @io.readbytes(1).should == [@b2].pack("C")
+    @io.readbits(2, :little).should == 0b10
+  end
+end
+
+class BitWriterHelper
+  def initialize
+    @stringio = StringIO.new
+    @io = BinData::IO.new(@stringio)
+  end
+
+  def writebits(val, nbits, endian = :big)
+    @io.writebits(val, nbits, endian)
+  end
+
+  def writebytes(val)
+    @io.writebytes(val)
+  end
+
+  def value
+    @io.flushbits
+    @stringio.rewind
+    @stringio.read
+  end
+end
+
+describe BinData::IO, "writing bits in big endian" do
+  before(:each) do
+    @io = BitWriterHelper.new
+  end
+
+  it "should write a bitfield less than 1 byte" do
+    @io.writebits(0b010, 3)
+    @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.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.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.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.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.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.writebytes([0b1011_1111].pack("C"))
+    @io.writebits(0b01, 2)
+
+    @io.value.should == [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
+  end
+end
+
+describe BinData::IO, "writing bits in little endian" do
+  before(:each) do
+    @io = BitWriterHelper.new
+  end
+
+  it "should write a bitfield less than 1 byte" do
+    @io.writebits(0b010, 3, :little)
+    @io.value.should == [0b0000_0010].pack("C")
+  end
+
+  it "should write a bitfield more than 1 byte" do
+    @io.writebits(0b10_1001_1101, 10, :little)
+    @io.value.should == [0b1001_1101, 0b0000_0010].pack("CC")
+  end
+
+  it "should write a bitfield more than 2 bytes" do
+    @io.writebits(0b101_1000_0010_1001_1101, 19, :little)
+    @io.value.should == [0b1001_1101, 0b1000_0010, 0b0000_0101].pack("CCC")
+  end
+
+  it "should write two bitfields totalling less than 1 byte" do
+    @io.writebits(0b1_1001, 5, :little)
+    @io.writebits(0b00, 2, :little)
+    @io.value.should == [0b0001_1001].pack("C")
+  end
+
+  it "should write two bitfields totalling more than 1 byte" do
+    @io.writebits(0b01_0101, 6, :little)
+    @io.writebits(0b001_1001, 7, :little)
+    @io.value.should == [0b0101_0101, 0b0000_0110].pack("CC")
+  end
+
+  it "should write two bitfields totalling more than 2 bytes" do
+    @io.writebits(0b01_0111, 6, :little)
+    @io.writebits(0b1_0010_1001_1001, 13, :little)
+    @io.value.should == [0b0101_0111, 0b1010_0110, 0b0000_0100].pack("CCC")
+  end
+
+  it "should pad unused bits when writing bytes" do
+    @io.writebits(0b101, 3, :little)
+    @io.writebytes([0b1011_1111].pack("C"))
+    @io.writebits(0b01, 2, :little)
+
+    @io.value.should == [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
+  end
+end
+
+describe BinData::IO, "with changing endian" do
+  it "should not mix different endianess when reading" do
+    b1 = 0b0110_1010
+    b2 = 0b1110_0010
+    str = [b1, b2].pack("CC")
+    io = BinData::IO.new(str)
+
+    io.readbits(3, :big).should == 0b011
+    io.readbits(4, :little).should == 0b0010
+  end
+
+  it "should not mix different endianess when writing" do
+    io = BitWriterHelper.new
+    io.writebits(0b110, 3, :big)
+    io.writebits(0b010, 3, :little)
+    io.value.should == [0b1100_0000, 0b0000_0010].pack("CC")
+  end
+end
+