bindata 1.5.1 → 1.6.0

data/lib/a.rb

@@ -1,24 +0,0 @@
-require 'bindata'
-
-class A < BinData::Choice
-  int8  1
-  uint8 :default
-end
-
-a = A.new(:selection => 1)
-
-p a.class
-
-class BinData::Choice
-  def selected_object
-    current_choice
-  end
-end
-
-case a.selected_object
-when BinData::Int8
-  p "int8"
-else
-  p "else"
-end
-

data/spec/array_spec.rb

@@ -1,331 +0,0 @@
-#!/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/array'
-require 'bindata/int'
-require 'bindata/string'
-
-describe BinData::Array, "when instantiating" do
-  context "with no mandatory parameters supplied" do
-    it "raises an error" do
-      args = {}
-      expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "with some but not all mandatory parameters supplied" do
-    it "raises an error" do
-      args = {:initial_length => 3}
-      expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
-    end
-  end
-
-  it "fails if a given type is unknown" do
-    args = {:type => :does_not_exist, :initial_length => 3}
-    expect { BinData::Array.new(args) }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-
-  it "does not allow both :initial_length and :read_until" do
-    args = {:initial_length => 3, :read_until => lambda { false } }
-    expect { BinData::Array.new(args) }.to raise_error(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.should == [5]
-  end
-end
-
-describe BinData::Array, "with no elements" do
-  subject { BinData::Array.new(:type => :example_single) }
-
-  it { should be_clear }
-  it { should be_empty }
-  its(:length) { should be_zero }
-  its(:first)  { should be_nil }
-  its(:last)   { should be_nil }
-
-  it "returns [] for the first n elements" do
-    subject.first(3).should == []
-  end
-
-  it "returns [] for the last n elements" do
-    subject.last(3).should == []
-  end
-end
-
-describe BinData::Array, "with several elements" do
-  subject {
-    type = [:example_single, {:initial_value => lambda { index + 1 }}]
-    BinData::Array.new(:type => type, :initial_length => 5)
-  }
-
-  it { should be_clear }
-  it { should_not be_empty }
-  its(:size) { should == 5 }
-  its(:length) { should == 5 }
-  its(:snapshot) { should == [1, 2, 3, 4, 5] }
-  its(:inspect) { should == "[1, 2, 3, 4, 5]" }
-
-  it "coerces to ::Array if required" do
-    [0].concat(subject).should == [0, 1, 2, 3, 4, 5]
-  end
-
-  it "uses methods from Enumerable" do
-    subject.select { |x| (x % 2) == 0 }.should == [2, 4]
-  end
-
-  it "assigns primitive values" do
-    subject.assign([4, 5, 6])
-    subject.should == [4, 5, 6]
-  end
-
-  it "assigns bindata objects" do
-    subject.assign([ExampleSingle.new(4), ExampleSingle.new(5), ExampleSingle.new(6)])
-    subject.should == [4, 5, 6]
-  end
-
-  it "assigns a bindata array" do
-    array = BinData::Array.new([4, 5, 6], :type => :example_single)
-    subject.assign(array)
-    subject.should == [4, 5, 6]
-  end
-
-  it "returns the first element" do
-    subject.first.should == 1
-  end
-
-  it "returns the first n elements" do
-    subject[0...3].should == [1, 2, 3]
-    subject.first(3).should == [1, 2, 3]
-    subject.first(99).should == [1, 2, 3, 4, 5]
-  end
-
-  it "returns the last element" do
-    subject.last.should == 5
-    subject[-1].should == 5
-  end
-
-  it "returns the last n elements" do
-    subject.last(3).should == [3, 4, 5]
-    subject.last(99).should == [1, 2, 3, 4, 5]
-
-    subject[-3, 100].should == [3, 4, 5]
-  end
-
-  it "clears all" do
-    subject[1] = 8
-    subject.clear
-    subject.should == [1, 2, 3, 4, 5]
-  end
-
-  it "clears a single element" do
-    subject[1] = 8
-    subject[1].clear
-    subject[1].should == 2
-  end
-
-  it "is clear if all elements are clear" do
-    subject[1] = 8
-    subject[1].clear
-    subject.should be_clear
-  end
-
-  it "tests clear status of individual elements" do
-    subject[1] = 8
-    subject[0].should be_clear
-    subject[1].should_not be_clear
-  end
-
-  it "directly accesses elements" do
-    subject[1] = 8
-    subject[1].should == 8
-  end
-
-  it "symmetrically reads and writes" do
-    subject[1] = 8
-    str = subject.to_binary_s
-
-    subject.clear
-    subject[1].should == 2
-
-    subject.read(str)
-    subject[1].should == 8
-  end
-
-  it "identifies index of elements" do
-    subject.index(3).should == 2
-  end
-
-  it "returns nil for index of non existent element" do
-    subject.index(42).should be_nil
-  end
-
-  it "has correct debug name" do
-    subject[2].debug_name.should == "obj[2]"
-  end
-
-  it "has correct offset" do
-    subject[2].offset.should == ExampleSingle.new.num_bytes * 2
-  end
-
-  it "has correct num_bytes" do
-    subject.num_bytes.should == 5 * ExampleSingle.new.num_bytes
-  end
-
-  it "has correct num_bytes for individual elements" do
-    subject[0].num_bytes.should == ExampleSingle.new.num_bytes
-  end
-end
-
-describe BinData::Array, "when accessing elements" do
-  subject {
-    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
-    subject.insert(2, 30, 40)
-    subject.snapshot.should == [1, 2, 30, 40, 3, 4, 5]
-  end
-
-  it "inserts with negative indexes" do
-    subject.insert(-2, 30, 40)
-    subject.snapshot.should == [1, 2, 3, 4, 30, 40, 5]
-  end
-
-  it "pushes" do
-    subject.push(30, 40)
-    subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
-  end
-
-  it "concats" do
-    subject.concat([30, 40])
-    subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
-  end
-
-  it "unshifts" do
-    subject.unshift(30, 40)
-    subject.snapshot.should == [30, 40, 1, 2, 3, 4, 5]
-  end
-
-  it "automatically extends on [index]" do
-    subject[9].should == 10
-    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  end
-
-  it "automatically extends on []=" do
-    subject[9] = 30
-    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
-  end
-
-  it "automatically extends on insert" do
-    subject.insert(7, 30, 40)
-    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 30, 40]
-  end
-
-  it "does not extend on at" do
-    subject.at(9).should be_nil
-    subject.length.should == 5
-  end
-
-  it "does not extend on [start, length]" do
-    subject[9, 2].should be_nil
-    subject.length.should == 5
-  end
-
-  it "does not extend on [range]" do
-    subject[9 .. 10].should be_nil
-    subject.length.should == 5
-  end
-
-  it "raises error on bad input to []" do
-    expect { subject["a"] }.to raise_error(TypeError)
-    expect { subject[1, "a"] }.to raise_error(TypeError)
-  end
-end
-
-describe BinData::Array, "with :read_until" do
-
-  context "containing +element+" do
-    it "reads until the sentinel is reached" do
-      read_until = lambda { element == 5 }
-      subject = BinData::Array.new(:type => :int8, :read_until => read_until)
-
-      subject.read "\x01\x02\x03\x04\x05\x06\x07\x08"
-      subject.should == [1, 2, 3, 4, 5]
-    end
-  end
-
-  context "containing +array+ and +index+" do
-    it "reads until the sentinel is reached" do
-      read_until = lambda { index >= 2 and array[index - 2] == 5 }
-      subject = BinData::Array.new(:type => :int8, :read_until => read_until)
-
-      subject.read "\x01\x02\x03\x04\x05\x06\x07\x08"
-      subject.should == [1, 2, 3, 4, 5, 6, 7]
-    end
-  end
-
-  context ":eof" do
-    it "reads records until eof" do
-      subject = BinData::Array.new(:type => :int8, :read_until => :eof)
-
-      subject.read "\x01\x02\x03"
-      subject.should == [1, 2, 3]
-    end
-
-    it "reads records until eof, ignoring partial records" do
-      subject = BinData::Array.new(:type => :int16be, :read_until => :eof)
-
-      subject.read "\x00\x01\x00\x02\x03"
-      subject.should == [1, 2]
-    end
-
-    it "reports exceptions" do
-      array_type = [:string, {:read_length => lambda { unknown_variable }}]
-      subject = BinData::Array.new(:type => array_type, :read_until => :eof)
-      expect { subject.read "\x00\x01\x00\x02\x03" }.to raise_error
-    end
-  end
-end
-
-describe BinData::Array, "nested within an Array" do
-  subject {
-    nested_array_params = { :type => [:int8, { :initial_value => :index }],
-                            :initial_length => lambda { index + 1 } }
-    BinData::Array.new(:type => [:array, nested_array_params],
-                       :initial_length => 3)
-  }
-
-  its(:snapshot) { should == [ [0], [0, 1], [0, 1, 2] ] }
-
-  it "maintains structure when reading" do
-    subject.read "\x04\x05\x06\x07\x08\x09"
-    subject.should == [ [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
-    subject = IntArray.new(:initial_length => 7)
-    subject.length.should == 7
-  end
-
-  it "overrides default parameters" do
-    subject = IntArray.new(:initial_length => 3, :initial_element_value => 5)
-    subject.to_binary_s.should == "\x00\x05\x00\x05\x00\x05"
-  end
-end
-

data/spec/base_primitive_spec.rb

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