bindata 1.5.1 → 1.6.0

data/test/base_test.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe "BinData::Base", "framework" do
+  class FrameworkBase < BinData::Base
+    class << self
+      attr_accessor :calls
+      def record_calls(&block)
+        self.calls = []
+        block.call
+      end
+    end
+
+    def initialize_instance
+      self.class.calls << :initialize_instance
+    end
+
+    def initialize_shared_instance
+      self.class.calls << :initialize_shared_instance
+    end
+
+    expose_methods_for_testing
+  end
+
+  let(:obj) do
+    FrameworkBase.record_calls { FrameworkBase.new }
+  end
+
+  it "raises errors on unimplemented methods" do
+    lambda { obj.clear?        }.must_raise NotImplementedError
+    lambda { obj.assign(nil)   }.must_raise NotImplementedError
+    lambda { obj.snapshot      }.must_raise NotImplementedError
+    lambda { obj.do_read(nil)  }.must_raise NotImplementedError
+    lambda { obj.do_write(nil) }.must_raise NotImplementedError
+    lambda { obj.do_num_bytes  }.must_raise NotImplementedError
+  end
+
+  it "calls initialize methods in order" do
+    FrameworkBase.record_calls { FrameworkBase.new }
+    FrameworkBase.calls.must_equal [:initialize_shared_instance, :initialize_instance]
+  end
+
+  it "does not call #initialize_shared_instance for prototypes" do
+    prototype = obj
+    FrameworkBase.record_calls { prototype.new }
+    FrameworkBase.calls.must_equal [:initialize_instance]
+  end
+end
+
+describe BinData::Base, "ArgExtractor" do
+  class ParamParserBase < BinData::Base
+    attr_reader :params
+    attr_reader :val
+
+    def assign(v)
+      @val = v
+    end
+  end
+
+  it "parses parameters" do
+    par = BinData::Base.new
+    data = [
+      [[3                ],  3,   [],   nil],
+      [[3,            par],  3,   [],   par],
+      [[   {:a => 1}     ],  nil, [:a], nil],
+      [[   {:a => 1}, par],  nil, [:a], par],
+      [[3, {:a => 1}     ],  3,   [:a], nil],
+      [[3, {:a => 1}, par],  3,   [:a], par],
+    ]
+
+    data.each do |el|
+      args, val, param_keys, parent = *el
+      obj = ParamParserBase.new(*args)
+      obj.val.must_be_same_as val
+      obj.params.keys.must_equal param_keys
+      obj.parent.must_be_same_as parent
+    end
+  end
+end
+
+describe BinData::Base do
+  class BaseStub < BinData::Base
+    # Override to avoid NotImplemented errors
+    def clear?; end
+    def assign(x); @data = x; end
+    def snapshot; @data; end
+    def do_read(io) end
+    def do_write(io) end
+    def do_num_bytes; end
+  end
+
+  let(:obj) { BaseStub.new }
+
+  it "::bindata_name returns lowercased name" do
+    BaseStub.bindata_name.must_equal "base_stub"
+  end
+
+  it "::read instantiates self" do
+    BaseStub.read("").must_be_instance_of BaseStub
+  end
+
+  it "#read returns self" do
+    obj.read("").must_equal obj
+  end
+
+  it "#write returns self" do
+    obj.write("").must_equal obj
+  end
+
+  it "#inspect is forwarded to snapshot" do
+    obj.stub :snapshot, [1, 2, 3] do
+      obj.inspect.must_equal obj.snapshot.inspect
+    end
+  end
+
+  it "#to_s is forwarded to snapshot" do
+    obj.stub :snapshot, [1, 2, 3] do
+      obj.to_s.must_equal obj.snapshot.to_s
+    end
+  end
+
+  it "pretty prints object as snapshot" do
+    actual_io = StringIO.new
+    expected_io = StringIO.new
+
+    obj.stub :snapshot, [1, 2, 3] do
+      require 'pp'
+      PP.pp(obj, actual_io)
+      PP.pp(obj.snapshot, expected_io)
+    end
+
+    actual_io.value.must_equal expected_io.value
+  end
+
+  it "#write writes the same as #to_binary_s" do
+    class WriteToSBase < BaseStub
+      def do_write(io) io.writebytes("abc"); end
+    end
+
+    obj = WriteToSBase.new
+    io = StringIO.new
+    obj.write(io)
+    io.value.must_equal obj.to_binary_s
+  end
+
+  it "#read is forwarded to #do_read" do
+    calls = []
+    called_clear = lambda { |*a| calls << :clear }
+    called_do_read = lambda { |*a| calls << :do_read }
+
+    obj.stub :clear, called_clear do
+      obj.stub :do_read, called_do_read do
+        obj.read(nil)
+      end
+    end
+
+    calls.must_equal [:clear, :do_read]
+  end
+
+  it "#write is forwarded to #do_write" do
+    calls = []
+    called_do_write = lambda { |*a| calls << :do_write }
+
+    obj.stub :do_write, called_do_write do
+      obj.write(nil)
+    end
+
+    calls.must_equal [:do_write]
+  end
+
+  it "#num_bytes is forwarded to #do_num_bytes" do
+    obj.stub :do_num_bytes, 42 do
+      obj.num_bytes.must_equal 42
+    end
+  end
+
+  it "#num_bytes rounds up fractional values" do
+    obj.stub :do_num_bytes, 42.1 do
+      obj.num_bytes.must_equal 43
+    end
+  end
+end

data/{spec/bits_spec.rb → test/bits_test.rb}

@@ -1,91 +1,62 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/bits'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
-describe "Bits of size 1" do
-  let(:bit_classes) { [BinData::Bit1, BinData::Bit1le] }
-
-  it "accept true as value" do
-    bit_classes.each do |bit_class|
-      subject = bit_class.new
-      subject.assign(true)
-      subject.should == 1
-    end
-  end
-
-  it "accept false as value" do
-    bit_classes.each do |bit_class|
-      subject = bit_class.new
-      subject.assign(false)
-      subject.should == 0
-    end
-  end
-
-  it "accept nil as value" do
-    bit_classes.each do |bit_class|
-      subject = bit_class.new
-      subject.assign(nil)
-      subject.should == 0
-    end
-  end
-end
+module AllBitfields
 
-shared_examples "All bitfields" do
-
-  it "have a sensible value of zero" do
+  def test_has_a_sensible_value_of_zero
     all_classes do |bit_class|
-      bit_class.new.should be_zero
+      bit_class.new.must_equal 0
     end
   end
 
-  it "avoid underflow" do
+  def test_avoids_underflow
     all_classes do |bit_class|
-      subject = bit_class.new
+      obj = bit_class.new
 
-      subject.assign(min_value - 1)
-      subject.should == min_value
+      obj.assign(min_value - 1)
+      obj.must_equal min_value
     end
   end
 
-  it "avoid overflow" do
+  def test_avoids_overflow
     all_classes do |bit_class|
-      subject = bit_class.new
+      obj = bit_class.new
 
-      subject.assign(max_value + 1)
-      subject.should == max_value
+      obj.assign(max_value + 1)
+      obj.must_equal max_value
     end
   end
 
-  it "assign values" do
+  def test_assign_values
     all_classes do |bit_class|
       some_values_within_range.each do |val|
-        subject = bit_class.new
-        subject.assign(val)
+        obj = bit_class.new
+        obj.assign(val)
 
-        subject.should == val
+        obj.must_equal val
       end
     end
   end
 
-  it "assign values from other bit objects" do
+  def test_assign_values_from_other_bit_objects
     all_classes do |bit_class|
       some_values_within_range.each do |val|
-        subject = bit_class.new
-        subject.assign(bit_class.new(val))
+        obj = bit_class.new
+        obj.assign(bit_class.new(val))
 
-        subject.should == val
+        obj.must_equal val
       end
     end
   end
 
-  it "symmetrically #read and #write" do
+  def test_symmetrically_read_and_write
     all_classes do |bit_class|
       some_values_within_range.each do |val|
-        subject = bit_class.new
-        subject.assign(val)
+        obj = bit_class.new
+        obj.assign(val)
 
-        subject.value_read_from_written.should == subject
+        obj.value_read_from_written.must_equal obj
       end
     end
   end
@@ -129,9 +100,9 @@ def generate_bit_classes_to_test(endian)
 end
 
 describe "Big endian bitfields" do
-  include_examples "All bitfields"
+  include AllBitfields
 
-  before(:all) do
+  before do
     @bits = generate_bit_classes_to_test(:big)
   end
 
@@ -140,15 +111,15 @@ describe "Big endian bitfields" do
       nbytes = (nbits + 7) / 8
       str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).should == 1 << (nbits - 1)
+      bit_class.read(str).must_equal 1 << (nbits - 1)
     end
   end
 end
 
 describe "Little endian bitfields" do
-  include_examples "All bitfields"
+  include AllBitfields
 
-  before(:all) do
+  before do
     @bits = generate_bit_classes_to_test(:little)
   end
 
@@ -157,7 +128,36 @@ describe "Little endian bitfields" do
       nbytes = (nbits + 7) / 8
       str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
 
-      bit_class.read(str).should == 1
+      bit_class.read(str).must_equal 1
     end
   end
 end
+
+describe "Bits of size 1" do
+  let(:bit_classes) { [BinData::Bit1, BinData::Bit1le] }
+
+  it "accept true as value" do
+    bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.assign(true)
+      obj.must_equal 1
+    end
+  end
+
+  it "accept false as value" do
+    bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.assign(false)
+      obj.must_equal 0
+    end
+  end
+
+  it "accept nil as value" do
+    bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.assign(nil)
+      obj.must_equal 0
+    end
+  end
+end
+

data/test/choice_test.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+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 = {}
+    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+
+    args = {:selection => 1}
+    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+
+    args = {:choices => []}
+    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+  end
+
+  it "fails when a given type is unknown" do
+    args = {:choices => [:does_not_exist], :selection => 0}
+    lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "fails when a given type is unknown" do
+    args = {:choices => {0 => :does_not_exist}, :selection => 0}
+    lambda { BinData::Choice.new(args) }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "fails when :choices Hash has a symbol as key" do
+    args = {:choices => {:a => :example_single}, :selection => 0}
+    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+  end
+
+  it "fails when :choices Hash has a nil key" do
+    args = {:choices => {nil => :example_single}, :selection => 0}
+    lambda { BinData::Choice.new(args) }.must_raise ArgumentError
+  end
+end
+
+module ChoiceInitializedWithArrayOrHash
+  def test_can_select_the_choice
+    obj.choice = 3
+    obj.must_equal 30
+  end
+
+  def test_shows_the_current_selection
+    obj.choice = 3
+    obj.selection.must_equal 3
+  end
+
+  def test_forwards_snapshot
+    obj.choice = 3
+    obj.snapshot.must_equal 30
+  end
+
+  def test_can_change_the_choice
+    obj.choice = 3
+
+    obj.choice = 7
+    obj.must_equal 70
+  end
+
+  def test_fails_if_no_choice_has_been_set
+    lambda { obj.to_s }.must_raise IndexError
+  end
+
+  def test_wont_select_an_invalid_choice
+    obj.choice = 99
+    lambda { obj.to_s }.must_raise IndexError
+  end
+
+  def test_wont_select_a_nil_choice
+    obj.choice = 1
+    lambda { obj.to_s }.must_raise IndexError
+  end
+
+  def test_handles_missing_methods_correctly
+    obj.choice = 3
+
+    obj.must_respond_to :value
+    obj.wont_respond_to :does_not_exist
+    lambda { obj.does_not_exist }.must_raise NoMethodError
+  end
+
+  def test_delegates_methods_to_the_selected_single_choice
+    obj.choice = 5
+    obj.num_bytes.must_equal ExampleSingle.new.num_bytes
+  end
+end
+
+describe BinData::Choice, "with sparse choices array" do
+  include ChoiceInitializedWithArrayOrHash
+
+  let(:obj) {
+    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 ChoiceInitializedWithArrayOrHash
+
+  let(:obj) {
+    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
+  let(:obj) {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices)
+  }
+
+  it "assigns raw values" do
+    obj.choice = 3
+    obj.assign(254)
+    obj.must_equal 254
+  end
+
+  it "assigns Single values" do
+    data = ExampleSingle.new(11)
+
+    obj.choice = 3
+    obj.assign(data)
+    obj.must_equal 11
+  end
+
+  it "clears" do
+    obj.choice = 3
+    obj.assign(254)
+
+    obj.clear
+    obj.must_equal 0
+  end
+
+  it "clears all possible choices" do
+    obj.choice = 3
+    obj.assign(10)
+    obj.choice = 5
+    obj.assign(11)
+
+    obj.clear
+
+    obj.choice = 3
+    obj.must_equal 0
+  end
+
+  it "is clear on initialisation" do
+    obj.choice = 3
+
+    assert obj.clear?
+  end
+
+  it "is not clear after assignment" do
+    obj.choice = 3
+    obj.assign(254)
+
+    refute obj.clear?
+  end
+
+  it "does not copy value when changing selection" do
+    obj.choice = 3
+    obj.assign(254)
+
+    obj.choice = 7
+    obj.wont_equal 254
+  end
+
+  it "behaves as value" do
+    obj.choice = 3
+    obj.assign(5)
+
+    (obj + 1).must_equal 6
+    (1 + obj).must_equal 6
+  end
+end
+
+describe BinData::Choice, "with copy_on_change => true" do
+  let(:obj) {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices, :copy_on_change => true)
+  }
+
+  it "copies value when changing selection" do
+    obj.choice = 3
+    obj.assign(254)
+
+    obj.choice = 7
+    obj.must_equal 254
+  end
+end
+
+describe BinData::Choice, "with :default" do
+  let(:choices) { { "a" => :int8, :default => :int16be } }
+
+  it "selects for existing case" do
+    obj = BinData::Choice.new(:selection => "a", :choices => choices)
+    obj.num_bytes.must_equal 1
+  end
+
+  it "selects for default case" do
+    obj = BinData::Choice.new(:selection => "other", :choices => choices)
+    obj.num_bytes.must_equal 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
+    obj = DerivedChoice.new
+    obj.num_bytes.must_equal 2
+  end
+
+  it "overides default parameter" do
+    obj = DerivedChoice.new(:selection => 'b')
+    obj.num_bytes.must_equal 4
+  end
+
+  it "selects default selection" do
+    obj = DerivedChoice.new(:selection => 'z')
+    obj.num_bytes.must_equal 8
+  end
+end