bindata 1.5.1 → 1.6.0

data/test/array_test.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe BinData::Array, "when instantiating" do
+  describe "with no mandatory parameters supplied" do
+    it "raises an error" do
+      args = {}
+      lambda { BinData::Array.new(args) }.must_raise ArgumentError
+    end
+  end
+
+  describe "with some but not all mandatory parameters supplied" do
+    it "raises an error" do
+      args = {:initial_length => 3}
+      lambda { BinData::Array.new(args) }.must_raise ArgumentError
+    end
+  end
+
+  it "fails if a given type is unknown" do
+    args = {:type => :does_not_exist, :initial_length => 3}
+    lambda { BinData::Array.new(args) }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "does not allow both :initial_length and :read_until" do
+    args = {:initial_length => 3, :read_until => lambda { false } }
+    lambda { BinData::Array.new(args) }.must_raise ArgumentError
+  end
+
+  it "accepts BinData::Base as :type" do
+    obj = BinData::Int8.new(:initial_value => 5)
+    array = BinData::Array.new(:type => obj, :initial_length => 1)
+    array.must_equal [5]
+  end
+end
+
+describe BinData::Array, "with no elements" do
+  let(:obj) { BinData::Array.new(:type => :example_single) }
+
+  it "initial state" do
+    assert obj.clear?
+    obj.must_be_empty
+    obj.length.must_equal 0
+    obj.first.must_be_nil
+    obj.last.must_be_nil
+  end
+
+  it "returns [] for the first n elements" do
+    obj.first(3).must_equal []
+  end
+
+  it "returns [] for the last n elements" do
+    obj.last(3).must_equal []
+  end
+end
+
+describe BinData::Array, "with several elements" do
+  let(:obj) {
+    type = [:example_single, {:initial_value => lambda { index + 1 }}]
+    BinData::Array.new(:type => type, :initial_length => 5)
+  }
+
+  it "initial state" do
+    assert obj.clear?
+    obj.wont_be_empty
+    obj.size.must_equal 5
+    obj.length.must_equal 5
+    obj.snapshot.must_equal [1, 2, 3, 4, 5]
+    obj.inspect.must_equal "[1, 2, 3, 4, 5]"
+  end
+
+  it "coerces to ::Array if required" do
+    [0].concat(obj).must_equal [0, 1, 2, 3, 4, 5]
+  end
+
+  it "uses methods from Enumerable" do
+    obj.select { |x| (x % 2) == 0 }.must_equal [2, 4]
+  end
+
+  it "assigns primitive values" do
+    obj.assign([4, 5, 6])
+    obj.must_equal [4, 5, 6]
+  end
+
+  it "assigns bindata objects" do
+    obj.assign([ExampleSingle.new(4), ExampleSingle.new(5), ExampleSingle.new(6)])
+    obj.must_equal [4, 5, 6]
+  end
+
+  it "assigns a bindata array" do
+    array = BinData::Array.new([4, 5, 6], :type => :example_single)
+    obj.assign(array)
+    obj.must_equal [4, 5, 6]
+  end
+
+  it "returns the first element" do
+    obj.first.must_equal 1
+  end
+
+  it "returns the first n elements" do
+    obj[0...3].must_equal [1, 2, 3]
+    obj.first(3).must_equal [1, 2, 3]
+    obj.first(99).must_equal [1, 2, 3, 4, 5]
+  end
+
+  it "returns the last element" do
+    obj.last.must_equal 5
+    obj[-1].must_equal 5
+  end
+
+  it "returns the last n elements" do
+    obj.last(3).must_equal [3, 4, 5]
+    obj.last(99).must_equal [1, 2, 3, 4, 5]
+
+    obj[-3, 100].must_equal [3, 4, 5]
+  end
+
+  it "clears all" do
+    obj[1] = 8
+    obj.clear
+    obj.must_equal [1, 2, 3, 4, 5]
+  end
+
+  it "clears a single element" do
+    obj[1] = 8
+    obj[1].clear
+    obj[1].must_equal 2
+  end
+
+  it "is clear if all elements are clear" do
+    obj[1] = 8
+    obj[1].clear
+    assert obj.clear?
+  end
+
+  it "tests clear status of individual elements" do
+    obj[1] = 8
+    assert obj[0].clear?
+    refute obj[1].clear?
+  end
+
+  it "directly accesses elements" do
+    obj[1] = 8
+    obj[1].must_equal 8
+  end
+
+  it "symmetrically reads and writes" do
+    obj[1] = 8
+    str = obj.to_binary_s
+
+    obj.clear
+    obj[1].must_equal 2
+
+    obj.read(str)
+    obj[1].must_equal 8
+  end
+
+  it "identifies index of elements" do
+    obj.index(3).must_equal 2
+  end
+
+  it "returns nil for index of non existent element" do
+    obj.index(42).must_be_nil
+  end
+
+  it "has correct debug name" do
+    obj[2].debug_name.must_equal "obj[2]"
+  end
+
+  it "has correct offset" do
+    obj[2].offset.must_equal ExampleSingle.new.num_bytes * 2
+  end
+
+  it "has correct num_bytes" do
+    obj.num_bytes.must_equal 5 * ExampleSingle.new.num_bytes
+  end
+
+  it "has correct num_bytes for individual elements" do
+    obj[0].num_bytes.must_equal ExampleSingle.new.num_bytes
+  end
+end
+
+describe BinData::Array, "when accessing elements" do
+  let(:obj) {
+    type = [:example_single, {:initial_value => lambda { index + 1 }}]
+    data = BinData::Array.new(:type => type, :initial_length => 5)
+    data.assign([1, 2, 3, 4, 5])
+    data
+  }
+
+  it "inserts with positive indexes" do
+    obj.insert(2, 30, 40)
+    obj.snapshot.must_equal [1, 2, 30, 40, 3, 4, 5]
+  end
+
+  it "inserts with negative indexes" do
+    obj.insert(-2, 30, 40)
+    obj.snapshot.must_equal [1, 2, 3, 4, 30, 40, 5]
+  end
+
+  it "pushes" do
+    obj.push(30, 40)
+    obj.snapshot.must_equal [1, 2, 3, 4, 5, 30, 40]
+  end
+
+  it "concats" do
+    obj.concat([30, 40])
+    obj.snapshot.must_equal [1, 2, 3, 4, 5, 30, 40]
+  end
+
+  it "unshifts" do
+    obj.unshift(30, 40)
+    obj.snapshot.must_equal [30, 40, 1, 2, 3, 4, 5]
+  end
+
+  it "automatically extends on [index]" do
+    obj[9].must_equal 10
+    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "automatically extends on []=" do
+    obj[9] = 30
+    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
+  end
+
+  it "automatically extends on insert" do
+    obj.insert(7, 30, 40)
+    obj.snapshot.must_equal [1, 2, 3, 4, 5, 6, 7, 30, 40]
+  end
+
+  it "does not extend on at" do
+    obj.at(9).must_be_nil
+    obj.length.must_equal 5
+  end
+
+  it "does not extend on [start, length]" do
+    obj[9, 2].must_be_nil
+    obj.length.must_equal 5
+  end
+
+  it "does not extend on [range]" do
+    obj[9 .. 10].must_be_nil
+    obj.length.must_equal 5
+  end
+
+  it "raises error on bad input to []" do
+    lambda { obj["a"] }.must_raise TypeError
+    lambda { obj[1, "a"] }.must_raise TypeError
+  end
+end
+
+describe BinData::Array, "with :read_until" do
+
+  describe "containing +element+" do
+    it "reads until the sentinel is reached" do
+      read_until = lambda { element == 5 }
+      obj = BinData::Array.new(:type => :int8, :read_until => read_until)
+
+      obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
+      obj.must_equal [1, 2, 3, 4, 5]
+    end
+  end
+
+  describe "containing +array+ and +index+" do
+    it "reads until the sentinel is reached" do
+      read_until = lambda { index >= 2 and array[index - 2] == 5 }
+      obj = BinData::Array.new(:type => :int8, :read_until => read_until)
+
+      obj.read "\x01\x02\x03\x04\x05\x06\x07\x08"
+      obj.must_equal [1, 2, 3, 4, 5, 6, 7]
+    end
+  end
+
+  describe ":eof" do
+    it "reads records until eof" do
+      obj = BinData::Array.new(:type => :int8, :read_until => :eof)
+
+      obj.read "\x01\x02\x03"
+      obj.must_equal [1, 2, 3]
+    end
+
+    it "reads records until eof, ignoring partial records" do
+      obj = BinData::Array.new(:type => :int16be, :read_until => :eof)
+
+      obj.read "\x00\x01\x00\x02\x03"
+      obj.must_equal [1, 2]
+    end
+
+    it "reports exceptions" do
+      array_type = [:string, {:read_length => lambda { unknown_variable }}]
+      obj = BinData::Array.new(:type => array_type, :read_until => :eof)
+      lambda { obj.read "\x00\x01\x00\x02\x03" }.must_raise NoMethodError
+    end
+  end
+end
+
+describe BinData::Array, "nested within an Array" do
+  let(:obj) {
+    nested_array_params = { :type => [:int8, { :initial_value => :index }],
+                            :initial_length => lambda { index + 1 } }
+    BinData::Array.new(:type => [:array, nested_array_params],
+                       :initial_length => 3)
+  }
+
+  it "#snapshot" do
+    obj.snapshot.must_equal [ [0], [0, 1], [0, 1, 2] ]
+  end
+
+  it "maintains structure when reading" do
+    obj.read "\x04\x05\x06\x07\x08\x09"
+    obj.must_equal [ [4], [5, 6], [7, 8, 9] ]
+  end
+end
+
+describe BinData::Array, "subclassed" do
+  class IntArray < BinData::Array
+    endian :big
+    default_parameter :initial_element_value => 0
+
+    uint16 :initial_value => :initial_element_value
+  end
+
+  it "forwards parameters" do
+    obj = IntArray.new(:initial_length => 7)
+    obj.length.must_equal 7
+  end
+
+  it "overrides default parameters" do
+    obj = IntArray.new(:initial_length => 3, :initial_element_value => 5)
+    obj.to_binary_s.must_equal "\x00\x05\x00\x05\x00\x05"
+  end
+end
+
+describe BinData::Array, "of bits" do
+  let(:obj) { BinData::Array.new(:type => :bit1, :initial_length => 15) }
+
+  it "reads" do
+    str = [0b0001_0100, 0b1000_1000].pack("CC")
+    obj.read(str)
+    obj[0].must_equal  0
+    obj[1].must_equal  0
+    obj[2].must_equal  0
+    obj[3].must_equal  1
+    obj[4].must_equal  0
+    obj[5].must_equal  1
+    obj[6].must_equal  0
+    obj[7].must_equal  0
+    obj[8].must_equal  1
+    obj[9].must_equal  0
+    obj[10].must_equal 0
+    obj[11].must_equal 0
+    obj[12].must_equal 1
+    obj[13].must_equal 0
+    obj[14].must_equal 0
+  end
+
+  it "writes" do
+    obj[3] = 1
+    obj.to_binary_s.must_equal [0b0001_0000, 0b0000_0000].pack("CC")
+  end
+
+  it "returns num_bytes" do
+    obj.num_bytes.must_equal 2
+  end
+
+  it "has correct offset" do
+    obj[7].offset.must_equal 0
+    obj[8].offset.must_equal 1
+  end
+end
+

data/test/base_primitive_test.rb

@@ -0,0 +1,312 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe BinData::BasePrimitive do
+  it "is not registered" do
+    lambda {
+      BinData::RegisteredClasses.lookup("BasePrimitive")
+    }.must_raise BinData::UnRegisteredTypeError
+  end
+end
+
+describe BinData::BasePrimitive, "all subclasses" do
+  class SubClassOfBasePrimitive < BinData::BasePrimitive
+    expose_methods_for_testing
+  end
+
+  let(:obj) { SubClassOfBasePrimitive.new }
+
+  it "raise errors on unimplemented methods" do
+    lambda { obj.value_to_binary_string(nil) }.must_raise NotImplementedError
+    lambda { obj.read_and_return_value(nil) }.must_raise NotImplementedError
+    lambda { obj.sensible_default }.must_raise NotImplementedError
+  end
+end
+
+describe ExampleSingle do
+  let(:obj) { ExampleSingle.new(5) }
+
+  it "fails when assigning nil values" do
+    lambda { obj.assign(nil) }.must_raise ArgumentError
+  end
+
+  it "sets and retrieves values" do
+    obj.assign(7)
+    obj.must_equal 7
+  end
+
+  it "sets and retrieves BinData::BasePrimitives" do
+    obj.assign(ExampleSingle.new(7))
+    obj.must_equal 7
+  end
+
+  it "responds to known methods" do
+    obj.must_respond_to :num_bytes
+  end
+
+  it "responds to known methods in #snapshot" do
+    obj.must_respond_to :div
+  end
+
+  it "does not respond to unknown methods in self or #snapshot" do
+    obj.wont_respond_to :does_not_exist
+  end
+
+  it "behaves as #snapshot" do
+    (obj + 1).must_equal 6
+    (1 + obj).must_equal 6
+  end
+
+  it "is equal to other ExampleSingle" do
+    obj.must_equal ExampleSingle.new(5)
+  end
+
+  it "is equal to raw values" do
+    obj.must_equal 5
+    5.must_equal obj
+  end
+
+  it "can be used as a hash key" do
+    hash = {5 => 17}
+
+    hash[obj].must_equal 17
+  end
+
+  it "is sortable" do
+    [ExampleSingle.new(5), ExampleSingle.new(3)].sort.must_equal [3, 5]
+  end
+end
+
+describe BinData::BasePrimitive, "after initialisation" do
+  let(:obj) { ExampleSingle.new }
+
+  it "does not allow both :initial_value and :value" do
+    params = {:initial_value => 1, :value => 2}
+    lambda { ExampleSingle.new(params) }.must_raise ArgumentError
+  end
+
+  it "initial state" do
+    assert obj.clear?
+    obj.value.must_equal 0
+    obj.num_bytes.must_equal 4
+  end
+
+  it "has symmetric IO" do
+    obj.assign(42)
+    written = obj.to_binary_s
+
+    ExampleSingle.read(written).must_equal 42
+  end
+
+  it "sets and retrieves values" do
+    obj.value = 5
+    obj.value.must_equal 5
+  end
+
+  it "is not clear after setting value" do
+    obj.assign(5)
+    refute obj.clear?
+  end
+
+  it "is not clear after reading" do
+    obj.read("\x11\x22\x33\x44")
+    refute obj.clear?
+  end
+
+  it "returns a snapshot" do
+    obj.assign(5)
+    obj.snapshot.must_equal 5
+  end
+end
+
+describe BinData::BasePrimitive, "with :initial_value" do
+  let(:obj) { ExampleSingle.new(:initial_value => 5) }
+
+  it "initial state" do
+    obj.value.must_equal 5
+  end
+
+  it "forgets :initial_value after being set" do
+    obj.assign(17)
+    obj.wont_equal 5
+  end
+
+  it "forgets :initial_value after reading" do
+    obj.read("\x11\x22\x33\x44")
+    obj.wont_equal 5
+  end
+
+  it "remembers :initial_value after being cleared" do
+    obj.assign(17)
+    obj.clear
+    obj.must_equal 5
+  end
+end
+
+describe BinData::BasePrimitive, "with :value" do
+  let(:obj) { ExampleSingle.new(:value => 5) }
+  let(:io)  { ExampleSingle.io_with_value(56) }
+
+  it "initial state" do
+    obj.value.must_equal 5
+  end
+
+  it "changes during reading" do
+    obj.read(io)
+    obj.stub :reading?, true do
+      obj.must_equal 56
+    end
+  end
+
+  it "does not change after reading" do
+    obj.read(io)
+    obj.must_equal 5
+  end
+
+  it "is unaffected by assigning" do
+    obj.assign(17)
+    obj.must_equal 5
+  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) }
+
+  describe ":assert is non boolean" do
+    it "succeeds when assert is correct" do
+      data = ExampleSingle.new(:assert => 12)
+      data.read(io)
+      data.value.must_equal 12
+    end
+
+    it "fails when assert is incorrect" do
+      data = ExampleSingle.new(:assert => lambda { 99 })
+      lambda { data.read(io) }.must_raise BinData::ValidityError
+    end
+  end
+
+  describe ":assert is boolean" do
+    it "succeeds when assert is true" do
+      data = ExampleSingle.new(:assert => lambda { value < 20 })
+      data.read(io)
+      data.value.must_equal 12
+    end
+
+    it "fails when assert is false" do
+      data = ExampleSingle.new(:assert => lambda { value > 20 })
+      lambda { data.read(io) }.must_raise BinData::ValidityError
+    end
+  end
+
+  describe "assigning with :assert" do
+    it "succeeds when assert is correct" do
+      data = ExampleSingle.new(:assert => 12)
+      data.assign(12)
+      data.value.must_equal 12
+    end
+
+    it "fails when assert is incorrect" do
+      data = ExampleSingle.new(:assert => 12)
+      lambda { data.assign(99) }.must_raise BinData::ValidityError
+    end
+  end
+end
+
+describe BinData::BasePrimitive, ":asserted_value" do
+  it "has :value" do
+    data = ExampleSingle.new(:asserted_value => lambda { 12 })
+    data.value.must_equal 12
+  end
+
+  describe "assigning with :assert" do
+    it "succeeds when assert is correct" do
+      data = ExampleSingle.new(:asserted_value => lambda { 12 })
+      data.assign(12)
+      data.value.must_equal 12
+    end
+
+    it "fails when assert is incorrect" do
+      data = ExampleSingle.new(:asserted_value => lambda { 12 })
+      lambda { data.assign(99) }.must_raise BinData::ValidityError
+    end
+  end
+end
+
+describe BinData::BasePrimitive do
+  it "conforms to rule 1 for returning a value" do
+    data = ExampleSingle.new(:value => 5)
+    data.must_equal 5
+  end
+
+  it "conforms to rule 2 for returning a value" do
+    io = ExampleSingle.io_with_value(42)
+    data = ExampleSingle.new(:value => 5)
+    data.read(io)
+
+    data.stub :reading?, true do
+      data.must_equal 42
+    end
+  end
+
+  it "conforms to rule 3 for returning a value" do
+    data = ExampleSingle.new(:initial_value => 5)
+    assert data.clear?
+    data.must_equal 5
+  end
+
+  it "conforms to rule 4 for returning a value" do
+    data = ExampleSingle.new(:initial_value => 5)
+    data.assign(17)
+    refute data.clear?
+    data.must_equal 17
+  end
+
+  it "conforms to rule 5 for returning a value" do
+    data = ExampleSingle.new
+    assert data.clear?
+    data.must_equal 0
+  end
+
+  it "conforms to rule 6 for returning a value" do
+    data = ExampleSingle.new
+    data.assign(8)
+    refute data.clear?
+    data.must_equal 8
+  end
+end
+