jbangert-bindata 1.5.0

data/spec/choice_spec.rb

@@ -0,0 +1,263 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require File.expand_path(File.join(File.dirname(__FILE__), "example"))
+require 'bindata/choice'
+require 'bindata/int'
+
+class Chooser
+  attr_accessor :choice
+end
+
+class BinData::Choice
+  def set_chooser(chooser)
+    @chooser = chooser
+  end
+  def choice=(s)
+    @chooser.choice = s
+  end
+end
+
+def create_choice(choices, options = {})
+  chooser = Chooser.new
+  params = {:choices => choices, :selection => lambda { chooser.choice } }.merge(options)
+  choice = BinData::Choice.new(params)
+  choice.set_chooser(chooser)
+  choice
+end
+
+describe BinData::Choice, "when instantiating" do
+  it "ensures mandatory parameters are supplied" do
+    args = {}
+    expect { BinData::Choice.new(args) }.to raise_error(ArgumentError)
+
+    args = {:selection => 1}
+    expect { BinData::Choice.new(args) }.to raise_error(ArgumentError)
+
+    args = {:choices => []}
+    expect { BinData::Choice.new(args) }.to raise_error(ArgumentError)
+  end
+
+  it "fails when a given type is unknown" do
+    args = {:choices => [:does_not_exist], :selection => 0}
+    expect { BinData::Choice.new(args) }.to raise_error(BinData::UnRegisteredTypeError)
+  end
+
+  it "fails when a given type is unknown" do
+    args = {:choices => {0 => :does_not_exist}, :selection => 0}
+    expect { BinData::Choice.new(args) }.to raise_error(BinData::UnRegisteredTypeError)
+  end
+
+  it "fails when :choices Hash has a symbol as key" do
+    args = {:choices => {:a => :example_single}, :selection => 0}
+    expect { BinData::Choice.new(args) }.to raise_error(ArgumentError)
+  end
+
+  it "fails when :choices Hash has a nil key" do
+    args = {:choices => {nil => :example_single}, :selection => 0}
+    expect { BinData::Choice.new(args) }.to raise_error(ArgumentError)
+  end
+end
+
+shared_examples "Choice initialized with array or hash" do
+  it "can select the choice" do
+    subject.choice = 3
+    subject.should == 30
+  end
+
+  it "shows the current selection" do
+    subject.choice = 3
+    subject.selection.should == 3
+  end
+
+  it "forwards #snapshot" do
+    subject.choice = 3
+    subject.snapshot.should == 30
+  end
+
+  it "can change the choice" do
+    subject.choice = 3
+
+    subject.choice = 7
+    subject.should == 70
+  end
+
+  it "fails if no choice has been set" do
+    expect { subject.to_s }.to raise_error(IndexError)
+  end
+
+  it "will not select an invalid choice" do
+    subject.choice = 99
+    expect { subject.to_s }.to raise_error(IndexError)
+  end
+
+  it "will not select a nil choice" do
+    subject.choice = 1
+    expect { subject.to_s }.to raise_error(IndexError)
+  end
+
+  it "handles missing methods correctly" do
+    subject.choice = 3
+
+    subject.should respond_to(:value)
+    subject.should_not respond_to(:does_not_exist)
+    expect { subject.does_not_exist }.to raise_error(NoMethodError)
+  end
+
+  it "delegates methods to the selected single choice" do
+    subject.choice = 5
+    subject.num_bytes.should == ExampleSingle.new.num_bytes
+  end
+end
+
+describe BinData::Choice, "with sparse choices array" do
+  include_examples "Choice initialized with array or hash"
+
+  subject {
+    choices = [nil, nil, nil,
+               [:example_single, {:value => 30}], nil,
+               [:example_single, {:value => 50}], nil,
+               [:example_single, {:value => 70}]]
+    create_choice(choices)
+  }
+end
+
+describe BinData::Choice, "with choices hash" do
+  include_examples "Choice initialized with array or hash"
+
+  subject {
+    choices = {3 => [:example_single, {:value => 30}],
+               5 => [:example_single, {:value => 50}],
+               7 => [:example_single, {:value => 70}]}
+    create_choice(choices)
+  }
+end
+
+describe BinData::Choice, "with single values" do
+  subject {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices)
+  }
+
+  it "assigns raw values" do
+    subject.choice = 3
+    subject.assign(254)
+    subject.should == 254
+  end
+
+  it "assigns Single values" do
+    obj = ExampleSingle.new(11)
+
+    subject.choice = 3
+    subject.assign(obj)
+    subject.should == 11
+  end
+
+  it "clears" do
+    subject.choice = 3
+    subject.assign(254)
+
+    subject.clear
+    subject.should be_zero
+  end
+
+  it "clears all possible choices" do
+    subject.choice = 3
+    subject.assign(10)
+    subject.choice = 5
+    subject.assign(11)
+
+    subject.clear
+
+    subject.choice = 3
+    subject.should be_zero
+  end
+
+  it "is clear on initialisation" do
+    subject.choice = 3
+
+    subject.should be_clear
+  end
+
+  it "is not clear after assignment" do
+    subject.choice = 3
+    subject.assign(254)
+
+    subject.should_not be_clear
+  end
+
+  it "does not copy value when changing selection" do
+    subject.choice = 3
+    subject.assign(254)
+
+    subject.choice = 7
+    subject.should_not == 254
+  end
+
+  it "behaves as value" do
+    subject.choice = 3
+    subject.assign(5)
+
+    (subject + 1).should == 6
+    (1 + subject).should == 6
+  end
+end
+
+describe BinData::Choice, "with copy_on_change => true" do
+  subject {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices, :copy_on_change => true)
+  }
+
+  it "copies value when changing selection" do
+    subject.choice = 3
+    subject.assign(254)
+
+    subject.choice = 7
+    subject.should == 254
+  end
+end
+
+describe BinData::Choice, "with :default" do
+  let(:choices) { { "a" => :int8, :default => :int16be } }
+
+  it "selects for existing case" do
+    subject = BinData::Choice.new(:selection => "a", :choices => choices)
+    subject.num_bytes.should == 1
+  end
+
+  it "selects for default case" do
+    subject = BinData::Choice.new(:selection => "other", :choices => choices)
+    subject.num_bytes.should == 2
+  end
+end
+
+describe BinData::Choice, "subclassed with default parameters" do
+  class DerivedChoice < BinData::Choice
+    endian :big
+    default_parameter :selection => 'a'
+
+    uint16 'a'
+    uint32 'b'
+    uint64 :default
+  end
+
+  it "sets initial selection" do
+    subject = DerivedChoice.new
+    subject.num_bytes.should == 2
+  end
+
+  it "overides default parameter" do
+    subject = DerivedChoice.new(:selection => 'b')
+    subject.num_bytes.should == 4
+  end
+
+  it "selects default selection" do
+    subject = DerivedChoice.new(:selection => 'z')
+    subject.num_bytes.should == 8
+  end
+end

data/spec/count_bytes_remaining_spec.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require 'bindata/count_bytes_remaining'
+
+describe BinData::CountBytesRemaining do
+  it { should == 0 }
+  its(:num_bytes) { should be_zero }
+
+  it "counts till end of stream" do
+    data = "abcdefghij"
+    subject.read(data).should == 10
+  end
+
+  it "does not read any data" do
+    io = StringIO.new "abcdefghij"
+    subject.read(io)
+
+    io.pos.should == 0
+  end
+
+  it "does not write any data" do
+    subject.to_binary_s.should == ""
+  end
+
+  it "allows setting value for completeness" do
+    subject.assign("123")
+    subject.should == "123"
+    subject.to_binary_s.should == ""
+  end
+
+  it "accepts BinData::BasePrimitive parameters" do
+    count = BinData::CountBytesRemaining.new(:check_value => 2)
+    expect {
+      count.read("xyz")
+    }.to raise_error(BinData::ValidityError)
+  end
+end

data/spec/deprecated_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require File.expand_path(File.join(File.dirname(__FILE__), "example"))
+require 'bindata'
+
+describe BinData::Base, "when defining" do
+  it "fails if #initialize is overridden" do
+    class BaseWithInitialize < BinData::Base
+      def initialize(params = {}, parent = nil)
+        super
+      end
+    end
+
+    expect {
+      BaseWithInitialize.new
+    }.to raise_error
+  end
+
+  it "handles if #initialize is naively renamed to #initialize_instance" do
+    class BaseWithInitializeInstance < BinData::Base
+      def initialize_instance(params = {}, parent = nil)
+        super
+      end
+    end
+
+    expect {
+      BaseWithInitializeInstance.new
+    }.to raise_error
+  end
+end

data/spec/example.rb

@@ -0,0 +1,21 @@
+require 'bindata/base_primitive'
+
+class ExampleSingle < BinData::BasePrimitive
+  def self.io_with_value(val)
+    BinData::IO.new([val].pack("V"))
+  end
+
+  private
+
+  def value_to_binary_string(val)
+    [val].pack("V")
+  end
+
+  def read_and_return_value(io)
+    io.readbytes(4).unpack("V").at(0)
+  end
+
+  def sensible_default
+    0
+  end
+end

data/spec/float_spec.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require 'bindata/float'
+
+describe "A FloatLe" do
+  subject { BinData::FloatLe.new(Math::PI) }
+
+  its(:num_bytes)               { should == 4 }
+  its(:to_binary_s)             { should == [Math::PI].pack('e') }
+  its(:value_read_from_written) { should be_within(0.000001).of(Math::PI) }
+end
+
+describe "A FloatBe" do
+  subject { BinData::FloatBe.new(Math::PI) }
+
+  its(:num_bytes)               { should == 4 }
+  its(:to_binary_s)             { should == [Math::PI].pack('g') }
+  its(:value_read_from_written) { should be_within(0.000001).of(Math::PI) }
+end
+
+describe "A DoubleLe" do
+  subject { BinData::DoubleLe.new(Math::PI) }
+
+  its(:num_bytes)               { should == 8 }
+  its(:to_binary_s)             { should == [Math::PI].pack('E') }
+  its(:value_read_from_written) { should be_within(0.0000000000000001).of(Math::PI) }
+end
+
+
+describe "A DoubleBe" do
+  subject { BinData::DoubleBe.new(Math::PI) }
+
+  its(:num_bytes)               { should == 8 }
+  its(:to_binary_s)             { should == [Math::PI].pack('G') }
+  its(:value_read_from_written) { should be_within(0.0000000000000001).of(Math::PI) }
+end

data/spec/int_spec.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require 'bindata'
+
+shared_examples "All Integers" do
+
+  it "have correct num_bytes" do
+    all_classes do |int_class|
+      int_class.new.num_bytes.should == @nbytes
+    end
+  end
+
+  it "have a sensible value of zero" do
+    all_classes do |int_class|
+      int_class.new.should be_zero
+    end
+  end
+
+  it "avoid underflow" do
+    all_classes do |int_class|
+      subject = int_class.new
+      subject.assign(min_value - 1)
+
+      subject.should == min_value
+    end
+  end
+
+  it "avoid overflow" do
+    all_classes do |int_class|
+      subject = int_class.new
+      subject.assign(max_value + 1)
+
+      subject.should == max_value
+    end
+  end
+
+  it "assign values" do
+    all_classes do |int_class|
+      subject = int_class.new
+      test_int = gen_test_int
+      subject.assign(test_int)
+
+      subject.should == test_int
+    end
+  end
+
+  it "assign values from other int objects" do
+    all_classes do |int_class|
+      src = int_class.new
+      src.assign(gen_test_int)
+
+      subject = int_class.new
+      subject.assign(src)
+      subject.should == src
+    end
+  end
+
+  it "symmetrically read and write a +ve number" do
+    all_classes do |int_class|
+      subject = int_class.new
+      subject.assign(gen_test_int)
+
+      subject.value_read_from_written.should == subject
+    end
+  end
+
+  it "symmetrically read and write a -ve number" do
+    all_classes do |int_class|
+      if @signed
+        subject = int_class.new
+        subject.assign(-gen_test_int)
+
+        subject.value_read_from_written.should == subject
+      end
+    end
+  end
+
+  it "convert a +ve number to string" do
+    all_classes do |int_class|
+      val = gen_test_int
+
+      subject = int_class.new
+      subject.assign(val)
+
+      subject.to_binary_s.should == int_to_binary_str(val)
+    end
+  end
+
+  it "convert a -ve number to string" do
+    all_classes do |int_class|
+      if @signed
+        val = -gen_test_int
+
+        subject = int_class.new
+        subject.assign(val)
+
+        subject.to_binary_s.should == int_to_binary_str(val)
+      end
+    end
+  end
+
+  def all_classes(&block)
+    @ints.each_pair do |int_class, nbytes|
+      @nbytes = nbytes
+      yield int_class
+    end
+  end
+
+  def min_value
+    if @signed
+      -max_value - 1
+    else
+      0
+    end
+  end
+
+  def max_value
+    if @signed
+      (1 << (@nbytes * 8 - 1)) - 1
+    else
+      (1 << (@nbytes * 8)) - 1
+    end
+  end
+
+  def gen_test_int
+    # resulting int is guaranteed to be +ve for signed or unsigned integers
+    (0 ... @nbytes).inject(0) { |val, i| (val << 8) | ((val + 0x11) % 0x100) }
+  end
+
+  def int_to_binary_str(val)
+    str = binary("")
+    v = val & ((1 << (@nbytes * 8)) - 1)
+    @nbytes.times do
+      str.concat(v & 0xff)
+      v >>= 8
+    end
+    (@endian == :little) ? str : str.reverse
+  end
+
+  def create_mapping_of_class_to_nbits(endian, signed)
+    base = signed ? "Int" : "Uint"
+    signed_sym = signed ? :signed : :unsigned
+    endian_str = (endian == :little) ? "le" : "be"
+
+    result = {}
+    result[BinData.const_get("#{base}8")] = 1
+    (1 .. 20).each do |nbytes|
+      nbits = nbytes * 8
+      class_name = "#{base}#{nbits}#{endian_str}"
+      result[BinData.const_get(class_name)] = nbytes
+    end
+
+    result
+  end
+end
+
+describe "All signed big endian integers" do
+  include_examples "All Integers"
+
+  before(:all) do
+    @endian = :big
+    @signed = true
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
+  end
+end
+
+describe "All unsigned big endian integers" do
+  include_examples "All Integers"
+
+  before(:all) do
+    @endian = :big
+    @signed = false
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
+  end
+end
+
+describe "All signed little endian integers" do
+  include_examples "All Integers"
+
+  before(:all) do
+    @endian = :little
+    @signed = true
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
+  end
+end
+
+describe "All unsigned little endian integers" do
+  include_examples "All Integers"
+
+  before(:all) do
+    @endian = :little
+    @signed = false
+    @ints = create_mapping_of_class_to_nbits(@endian, @signed)
+  end
+end
+
+describe "Custom defined integers" do
+  it "fail unless bits are a multiple of 8" do
+    expect {
+      BinData::Uint7le
+    }.to raise_error
+
+    expect {
+      BinData::Uint7be
+    }.to raise_error
+
+    expect {
+      BinData::Int7le
+    }.to raise_error
+
+    expect {
+      BinData::Int7be
+    }.to raise_error
+  end
+end