bindata 0.5.0

data/spec/lazy_spec.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/lazy'
+
+# A mock data object that can substitute for BinData::Simple or BinData::Struct
+class MockDataObject
+  def initialize(value = nil, fields = {})
+    @value = value
+    @fields = fields
+  end
+  attr_accessor :value
+
+  def field_names
+    @fields.keys.collect { |k| k.to_s }
+  end
+  def respond_to?(symbol, include_private = false)
+    field_names.include?(symbol.id2name) ? true : super
+  end
+  def method_missing(symbol, *args)
+    @fields[symbol] || super
+  end
+end
+
+context "A single environment" do
+  setup do
+    @do1 = MockDataObject.new('v1', :f1 => 'f1')
+    @e1 = BinData::LazyEvalEnv.new
+    @e1.data_object = @do1
+    @e1.params = {:p1 => 'p1'}
+  end
+
+  specify "should evaluate value" do
+    @e1.lazy_eval(lambda { value }).should == 'v1'
+  end
+
+  specify "should evaluate index" do
+    @e1.index = 7
+    @e1.lazy_eval(lambda { index }).should == 7
+  end
+
+  specify "should evaluate offset" do
+    @e1.offset = 9
+    @e1.lazy_eval(lambda { offset }).should == 9
+  end
+
+  specify "should not resolve any unknown fields" do
+    lambda { @e1.lazy_eval(lambda { unknown }) }.should raise_error(NameError)
+    lambda { @e1.lazy_eval(lambda { p1 }) }.should raise_error(NameError)
+    lambda { @e1.lazy_eval(lambda { f1 }) }.should raise_error(NameError)
+  end
+
+  specify "should accept symbols as a shortcut to lambda" do
+    @e1.index  = 7
+    @e1.offset = 9
+    @e1.lazy_eval(:value).should == 'v1'
+    @e1.lazy_eval(:index).should == 7
+    @e1.lazy_eval(:offset).should == 9
+  end
+end
+
+context "An environment with one parent" do
+  setup do
+    @do2 = MockDataObject.new(nil, :f2 => 'f2', :common => 'field2')
+    @do1 = MockDataObject.new
+
+    @e2 = BinData::LazyEvalEnv.new
+    @e1 = BinData::LazyEvalEnv.new(@e2)
+
+    @e2.data_object = @do2
+    @e1.data_object = @do1
+
+    @e2.params = {:p2 => 'p2', :l2 => lambda { 'l2' }, :common => 'param2'}
+  end
+
+  specify "should evaluate parent parameter" do
+    @e1.lazy_eval(:p2).should == 'p2'
+  end
+
+  specify "should evaluate parent field" do
+    @e1.lazy_eval(:f2).should == 'f2'
+  end
+
+  specify "should prefer parent param over parent field" do
+    @e1.lazy_eval(:common).should == 'param2'
+  end
+end
+
+context "A nested environment" do
+  setup do
+    @do4 = MockDataObject.new(nil, :f4 => 'f4')
+    @do3 = MockDataObject.new(nil, :f3 => 'f3')
+    @do2 = MockDataObject.new(nil, :f2 => 'f2')
+    @do1 = MockDataObject.new(nil, :f1 => 'f1')
+
+    @e4 = BinData::LazyEvalEnv.new
+    @e3 = BinData::LazyEvalEnv.new(@e4)
+    @e2 = BinData::LazyEvalEnv.new(@e3)
+    @e1 = BinData::LazyEvalEnv.new(@e2)
+
+    @e4.data_object = @do4
+    @e3.data_object = @do3
+    @e2.data_object = @do2
+    @e1.data_object = @do1
+
+    @e4.params = {:p4 => 'p4', :s4 => 's4', :l4 => 'l4'}
+    @e3.params = {:p3 => 'p3', :s3 => :s4, :l3 => lambda { l4 }}
+    @e2.params = {:p2 => 'p2', :s2 => :s3, :l2 => lambda { l3 }}
+  end
+
+  specify "should access parent environments" do
+    @e1.lazy_eval(lambda { parent.p3 }).should == 'p3'
+    @e1.lazy_eval(lambda { parent.parent.p4 }).should == 'p4'
+  end
+
+  specify "should cascade lambdas" do
+    @e1.lazy_eval(lambda { l2 }).should == 'l4'
+    @e1.lazy_eval(lambda { s2 }).should == 's4'
+  end
+end

data/spec/registry_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/registry'
+
+context "The Registry" do
+  setup do
+    @r = BinData::Registry.instance
+  end
+
+  specify "should be a singleton" do
+    BinData::Registry.instance.should equal(BinData::Registry.instance)
+  end
+
+  specify "should lookup registered names" do
+    A = Class.new
+    B = Class.new
+    @r.register('ASubClass', A)
+    @r.register('AnotherSubClass', B)
+
+    @r.lookup('a_sub_class').should == A
+    @r.lookup('another_sub_class').should == B
+  end
+
+  specify "should not lookup unregistered names" do
+    @r.lookup('a_non_existent_sub_class').should be_nil
+  end
+
+  specify "should convert CamelCase to underscores" do
+    @r.register('CamelCase', A).should == 'camel_case'
+  end
+
+  specify "should convert adjacent caps camelCase to underscores" do
+    @r.register('XYZCamelCase', A).should == 'xyz_camel_case'
+  end
+
+  specify "should ignore the outer nestings of classes" do
+    @r.register('A::B::C', A).should == 'c'
+  end
+
+  specify "should allow overriding of registered classes" do
+    @r.register('A', A)
+    @r.register('A', B)
+
+    @r.lookup('a').should == B
+  end
+end

data/spec/single_spec.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/single'
+
+# An implementation of a unsigned 4 byte integer.
+class ConcreteSingle < BinData::Single
+  def val_to_str(val)    [val].pack("V") end
+  def read_val(io)       readbytes(io, 4).unpack("V")[0] end
+  def sensible_default() 0 end
+
+  def in_read?()         @in_read end
+end
+
+context "The sample implementation of Single" do
+  specify "should have symmetric IO" do
+    io = StringIO.new
+    data = ConcreteSingle.new
+    data.value = 42
+    data.write(io)
+
+    io.rewind
+    data = ConcreteSingle.new
+    data.read(io)
+    data.value.should == 42
+  end
+end
+
+context "The class Single" do
+  specify "should register subclasses" do
+    BinData::Single.lookup(:concrete_single).should == ConcreteSingle
+  end
+
+  specify "should read and return a value" do
+    io = StringIO.new([123456].pack("V"))
+    ConcreteSingle.read(io).should == 123456
+    data = ConcreteSingle.new
+  end
+end
+
+context "A Single object" do
+  specify "should conform to rule 1 for returning a value" do
+    data = ConcreteSingle.new(:value => 5)
+    data.should_not be_in_read
+    data.value.should == 5
+  end
+
+  specify "should conform to rule 2 for returning a value" do
+    io = StringIO.new([42].pack("V"))
+    data = ConcreteSingle.new(:value => 5)
+    data.do_read(io)
+    data.should be_in_read
+    data.value.should == 42
+  end
+
+  specify "should conform to rule 3 for returning a value" do
+    data = ConcreteSingle.new(:initial_value => 5)
+    data.should be_clear
+    data.value.should == 5
+  end
+
+  specify "should conform to rule 4 for returning a value" do
+    data = ConcreteSingle.new(:initial_value => 5)
+    data.value = 17
+    data.should_not be_clear
+    data.value.should == 17
+  end
+
+  specify "should conform to rule 5 for returning a value" do
+    data = ConcreteSingle.new
+    data.should be_clear
+    data.value.should == 0
+  end
+
+  specify "should conform to rule 6 for returning a value" do
+    data = ConcreteSingle.new
+    data.value = 8
+    data.should_not be_clear
+    data.value.should == 8
+  end
+end
+
+context "A new Single object" do
+  setup do
+    @data = ConcreteSingle.new
+  end
+
+  specify "should not allow both :initial_value and :value" do
+    params = {:initial_value => 1, :value => 2}
+    lambda { ConcreteSingle.new(params) }.should raise_error(ArgumentError)
+  end
+
+  specify "should have a sensible value" do
+    @data.value.should == 0
+  end
+
+  specify "should allowing setting and retrieving value" do
+    @data.value = 5
+    @data.value.should == 5
+  end
+
+  specify "should be clear" do
+    @data.should be_clear
+  end
+
+  specify "should not be clear after setting value" do
+    @data.value = 5
+    @data.should_not be_clear
+  end
+
+  specify "should not be clear after reading" do
+    io = StringIO.new([123456].pack("V"))
+    @data.read(io)
+    @data.should_not be_clear
+  end
+
+  specify "should return num_bytes" do
+    @data.num_bytes.should == 4
+  end
+
+  specify "should not contain any field names" do
+    @data.field_names.should be_empty
+  end
+
+  specify "should return a snapshot" do
+    @data.value = 5
+    @data.snapshot.should == 5
+  end
+end
+
+context "A Single with :initial_value" do
+  setup do
+    @data = ConcreteSingle.new(:initial_value => 5)
+  end
+
+  specify "should return that initial value before reading or being set" do
+    @data.value.should == 5
+  end
+
+  specify "should forget :initial_value after being set" do
+    @data.value = 17
+    @data.value.should_not == 5
+  end
+
+  specify "should forget :initial_value after reading" do
+    io = StringIO.new([56].pack("V"))
+    @data.read(io)
+    @data.value.should_not == 5
+  end
+
+  specify "should remember :initial_value after being cleared" do
+    @data.value = 17
+    @data.clear
+    @data.value.should == 5
+  end
+end
+
+context "A Single with :value" do
+  setup do
+    @data = ConcreteSingle.new(:value => 5)
+  end
+
+  specify "should return that :value" do
+    @data.value.should == 5
+  end
+
+  specify "should change during reading" do
+    io = StringIO.new([56].pack("V"))
+    @data.do_read(io)
+    @data.value.should == 56
+    @data.done_read
+  end
+
+  specify "should not change after reading" do
+    io = StringIO.new([56].pack("V"))
+    @data.read(io)
+    @data.value.should == 5
+  end
+
+  specify "should not be able to change the value" do
+    @data.value = 17
+    @data.value.should == 5
+  end
+end
+
+context "A Single with :check_value" do
+  setup do
+    @io = StringIO.new([34].pack("V"))
+  end
+
+  specify "should succeed when check_value is non boolean and correct" do
+    data = ConcreteSingle.new(:check_value => 34)
+    lambda { data.read(@io) }.should_not raise_error
+  end
+
+  specify "should fail when check_value is non boolean and incorrect" do
+    data = ConcreteSingle.new(:check_value => lambda { 123 * 5 })
+    lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
+  end
+
+  specify "should succeed when check_value is boolean and true" do
+    data = ConcreteSingle.new(:check_value => lambda { (value % 2) == 0})
+    lambda { data.read(@io) }.should_not raise_error
+  end
+
+  specify "should fail when check_value is boolean and false" do
+    data = ConcreteSingle.new(:check_value => lambda { value > 100 })
+    lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
+  end
+end

data/spec/spec_common.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+begin
+  require 'rubygems'
+  gem 'rspec', '> 0.8.0'
+rescue LoadError
+end
+
+require 'spec'
+require 'stringio'

data/spec/string_spec.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/string'
+
+context "Test mutual exclusion of parameters" do
+  specify ":value and :initial_value" do
+    params = {:value => "", :initial_value => ""}
+    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+  end
+
+  specify ":length and :initial_length" do
+    params = {:length => 5, :initial_length => 5}
+    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+  end
+
+  specify ":initial_value and :initial_length" do
+    params = {:initial_value => "", :initial_length => 5}
+    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+  end
+
+  specify ":value and :length" do
+    params = {:value => "", :length => 5}
+    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+  end
+end
+
+context "A String with :initial_length" do
+  setup do
+    @str = BinData::String.new(:initial_length => 5)
+  end
+
+  specify "should set num_bytes" do
+    @str.num_bytes.should == 5
+  end
+
+  specify "should fill value with pad_char" do
+    @str.value.should == "\0\0\0\0\0"
+  end
+
+  specify "should read :initial_length bytes" do
+    io = StringIO.new("abcdefghij")
+    @str.read(io)
+    @str.value.should == "abcde"
+  end
+
+  specify "should forget :initial_length after value is set" do
+    @str.value = "abc"
+    @str.num_bytes.should == 3
+  end
+
+  specify "should remember :initial_length after value is cleared" do
+    @str.value = "abc"
+    @str.num_bytes.should == 3
+    @str.clear
+    @str.num_bytes.should == 5
+  end
+end
+
+context "A String with :length" do
+  setup do
+    @str = BinData::String.new(:length => 5)
+  end
+
+  specify "should set num_bytes" do
+    @str.num_bytes.should == 5
+  end
+
+  specify "should fill value with pad_char" do
+    @str.value.should == "\0\0\0\0\0"
+  end
+
+  specify "should retain :length after value is set" do
+    @str.value = "abcdefghij"
+    @str.num_bytes.should == 5
+  end
+
+  specify "should read :length bytes" do
+    io = StringIO.new("abcdefghij")
+    @str.read(io)
+    @str.value.should == "abcde"
+  end
+
+  specify "should pad values less than :length" do
+    @str.value = "abc"
+    @str.value.should == "abc\0\0"
+  end
+
+  specify "should accept values exactly :length" do
+    @str.value = "abcde"
+    @str.value.should == "abcde"
+  end
+
+  specify "should truncate values greater than :length" do
+    @str.value = "abcdefg"
+    @str.value.should == "abcde"
+  end
+end
+
+context "A String with :initial_length and :value" do
+  setup do
+    @str = BinData::String.new(:initial_length => 5, :value => "abcdefghij")
+  end
+
+  specify "should use :initial_length before value is read" do
+    @str.num_bytes.should == 5
+    @str.value.should == "abcde"
+  end
+
+  specify "should use :initial_length for reading" do
+    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
+    @str.read(io)
+    io.pos.should == 5
+   end
+
+  specify "should forget :initial_length after reading" do
+    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
+    @str.read(io)
+    @str.num_bytes.should == 10
+    @str.value.should == "abcdefghij"
+  end
+
+  specify "should return read value before calling done_read" do
+    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
+
+    @str.do_read(io)
+    @str.value.should == "ABCDE"
+
+    @str.done_read
+    @str.value.should == "abcdefghij"
+  end
+end
+
+context "A String with :length and :initial_value" do
+  setup do
+    @str = BinData::String.new(:length => 5, :initial_value => "abcdefghij")
+  end
+
+  specify "should apply :length to :initial_value" do
+    @str.num_bytes.should == 5
+    @str.value.should == "abcde"
+  end
+
+  specify "should forget :initial_value after reading" do
+    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
+    @str.read(io)
+    io.pos.should == 5
+    @str.num_bytes.should == 5
+    @str.value.should == "ABCDE"
+  end
+end
+
+context "A String with :pad_char" do
+  specify "should accept a numeric value for :pad_char" do
+    @str = BinData::String.new(:length => 5, :pad_char => 6)
+    @str.value = "abc"
+    @str.value.should == "abc\x06\x06"
+  end
+
+  specify "should accept a character for :pad_char" do
+    @str = BinData::String.new(:length => 5, :pad_char => "R")
+    @str.value = "abc"
+    @str.value.should == "abcRR"
+  end
+
+  specify "should not accept a string for :pad_char" do
+    params = {:length => 5, :pad_char => "RR"}
+    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+  end
+end
+
+context "A String with :trim_value" do
+  specify "set false is the default" do
+    str1 = BinData::String.new(:length => 5)
+    str2 = BinData::String.new(:length => 5, :trim_value => false)
+    str1.value = "abc"
+    str2.value = "abc"
+    str1.value.should == "abc\0\0"
+    str2.value.should == "abc\0\0"
+  end
+
+  specify "should trim the value" do
+    str = BinData::String.new(:pad_char => 'R', :trim_value => true)
+    str.value = "abcRR"
+    str.value.should == "abc"
+  end
+
+  specify "should not affect num_bytes" do
+    str = BinData::String.new(:pad_char => 'R', :trim_value => true)
+    str.value = "abcRR"
+    str.num_bytes.should == 5
+  end
+
+  specify "should trim if last char is :pad_char" do
+    str = BinData::String.new(:pad_char => 'R', :trim_value => true)
+    str.value = "abcRR"
+    str.value.should == "abc"
+  end
+
+  specify "should not trim if value contains :pad_char not at the end" do
+    str = BinData::String.new(:pad_char => 'R', :trim_value => true)
+    str.value = "abcRRde"
+    str.value.should == "abcRRde"
+  end
+end