bindata 1.2.2 → 1.3.1

data/spec/alignment_spec.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
+require 'bindata'
+
+describe BinData::ResumeByteAlignment do
+  class ResumeAlignmentRecord < BinData::Record
+    bit4 :a
+    resume_byte_alignment
+    bit4 :b
+  end
+
+  subject { ResumeAlignmentRecord.new }
+
+  it "should reset read alignment" do
+    subject.read "\x12\x34"
+
+    subject.a.should == 1
+    subject.b.should == 3
+  end
+
+  it "should reset write alignment" do
+    subject.assign(:a => 2, :b => 7)
+
+    subject.to_binary_s.should == "\x20\x70"
+  end
+end
+
+describe BinData::BitAligned do
+  it "should not apply to BinData::Primitives" do
+    lambda {
+      class BitAlignedPrimitive < BinData::Primitive
+        bit_aligned
+      end
+    }.should raise_error
+  end
+
+  class BitString < BinData::String
+    bit_aligned
+  end
+
+  class BitAlignedRecord < BinData::Record
+    bit4 :preamble
+    bit_string :str, :length => 2
+    bit4 :afterward
+  end
+
+  subject { BitAlignedRecord.new }
+
+  its(:num_bytes) { should == 3 }
+
+  it "should read" do
+    subject.read("\x56\x36\x42")
+    subject.should == {"preamble" => 5, "str" => "cd", "afterward" => 2}
+  end
+
+  it "should write" do
+    subject.assign(:preamble => 5, :str => "ab", :afterward => 1)
+    subject.to_binary_s.should == "\x56\x16\x21"
+  end
+end

data/spec/array_spec.rb

@@ -25,313 +25,274 @@ describe BinData::Array, "when instantiating" do
 end
 
 describe BinData::Array, "with no elements" do
-  before(:each) do
-    @data = BinData::Array.new(:type => :example_single)
-  end
-
-  it "should be clear" do
-    @data.should be_clear
-  end
+  subject { BinData::Array.new(:type => :example_single) }
 
-  it "should return zero length" do
-    @data.length.should be_zero
-  end
-
-  it "should be empty" do
-    @data.should be_empty
-  end
+  it { should be_clear }
+  it { should be_empty }
+  its(:length) { should be_zero }
 
   it "should return nil for the first element" do
-    @data.first.should be_nil
+    subject.first.should be_nil
   end
 
   it "should return [] for the first n elements" do
-    @data.first(3).should == []
+    subject.first(3).should == []
   end
 
   it "should return nil for the last element" do
-    @data.last.should be_nil
+    subject.last.should be_nil
   end
 
   it "should return [] for the last n elements" do
-    @data.last(3).should == []
+    subject.last(3).should == []
   end
 end
 
 describe BinData::Array, "with several elements" do
-  before(:each) do
+  subject {
     type = [:example_single, {:initial_value => lambda { index + 1 }}]
-    @data = BinData::Array.new(:type => type, :initial_length => 5)
-  end
+    BinData::Array.new(:type => type, :initial_length => 5)
+  }
 
-  it "should have correct debug name" do
-    @data[2].debug_name.should == "obj[2]"
-  end
+  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 "should have correct offset" do
-    @data[2].offset.should == ExampleSingle.new.num_bytes * 2
+  it "should coerce to ::Array if required" do
+    [0].concat(subject).should == [0, 1, 2, 3, 4, 5]
   end
 
-  it "should return a correct snapshot" do
-    @data.snapshot.should == [1, 2, 3, 4, 5]
+  it "should be able to use methods from Enumerable" do
+    subject.select { |x| (x % 2) == 0 }.should == [2, 4]
   end
 
   it "should assign primitive values" do
-    @data.assign([4, 5, 6])
-    @data.snapshot.should == [4, 5, 6]
+    subject.assign([4, 5, 6])
+    subject.should == [4, 5, 6]
   end
 
   it "should assign bindata objects" do
-    o1 = ExampleSingle.new
-    o1.value = 4
-    o2 = ExampleSingle.new
-    o2.value = 5
-    o3 = ExampleSingle.new
-    o3.value = 6
-    @data.assign([o1, o2, o3])
-    @data.snapshot.should == [4, 5, 6]
+    subject.assign([ExampleSingle.new(4), ExampleSingle.new(5), ExampleSingle.new(6)])
+    subject.should == [4, 5, 6]
   end
 
   it "should assign bindata array" do
     array = BinData::Array.new(:type => :example_single)
     array.push(4, 5, 6)
-    @data.assign(array)
-    @data.snapshot.should == [4, 5, 6]
-  end
-
-  it "should coerce to ::Array if required" do
-    [0].concat(@data).should == [0, 1, 2, 3, 4, 5]
+    subject.assign(array)
+    subject.should == [4, 5, 6]
   end
 
   it "should return the first element" do
-    @data.first.should == 1
+    subject.first.should == 1
   end
 
   it "should return the first n elements" do
-    @data[0...3].should == [1, 2, 3]
-    @data.first(3).should == [1, 2, 3]
-    @data.first(99).should == [1, 2, 3, 4, 5]
+    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 "should return the last element" do
-    @data.last.should == 5
-    @data[-1].should == 5
+    subject.last.should == 5
+    subject[-1].should == 5
   end
 
   it "should return the last n elements" do
-    @data.last(3).should == [3, 4, 5]
-    @data.last(99).should == [1, 2, 3, 4, 5]
+    subject.last(3).should == [3, 4, 5]
+    subject.last(99).should == [1, 2, 3, 4, 5]
 
-    @data[-3, 100].should == [3, 4, 5]
+    subject[-3, 100].should == [3, 4, 5]
   end
 
-  it "should have correct num elements" do
-    @data.length.should == 5
-    @data.size.should == 5
+  it "should clear" do
+    subject[1] = 8
+    subject.clear
+    subject.should == [1, 2, 3, 4, 5]
   end
 
-  it "should have correct num_bytes" do
-    @data.num_bytes.should == 5 * ExampleSingle.new.num_bytes
+  it "should clear a single element" do
+    subject[1] = 8
+    subject[1].clear
+    subject[1].should == 2
   end
 
-  it "should have correct num_bytes for individual elements" do
-    @data[0].num_bytes.should == ExampleSingle.new.num_bytes
+  it "should be clear if all elements are clear" do
+    subject[1] = 8
+    subject[1].clear
+    subject.should be_clear
   end
 
-  it "should be able to directly access elements" do
-    @data[1] = 8
-    @data[1].should == 8
+  it "should test clear status of individual elements" do
+    subject[1] = 8
+    subject[0].should be_clear
+    subject[1].should_not be_clear
   end
 
-  it "should not be empty" do
-    @data.should_not be_empty
+  it "should be able to directly access elements" do
+    subject[1] = 8
+    subject[1].should == 8
   end
 
-  it "should return a nicely formatted array for inspect" do
-    @data.inspect.should == "[1, 2, 3, 4, 5]"
-  end
+  it "should symmetrically read and write" do
+    subject[1] = 8
+    str = subject.to_binary_s
 
-  it "should be able to use methods from Enumerable" do
-    @data.select { |x| (x % 2) == 0 }.should == [2, 4]
-  end
+    subject.clear
+    subject[1].should == 2
 
-  it "should clear" do
-    @data[1] = 8
-    @data.clear
-    @data.should == [1, 2, 3, 4, 5]
+    subject.read(str)
+    subject[1].should == 8
   end
 
-  it "should clear a single element" do
-    @data[1] = 8
-    @data[1].clear
-    @data[1].should == 2
-  end
-
-  it "should be clear upon creation" do
-    @data.should be_clear
+  it "should identify index of elements" do
+    subject.index(3).should == 2
   end
 
-  it "should be clear if all elements are clear" do
-    @data[1] = 8
-    @data[1].clear
-    @data.should be_clear
+  it "should return nil for index of non existent element" do
+    subject.index(42).should be_nil
   end
 
-  it "should test clear status of individual elements" do
-    @data[1] = 8
-    @data[0].should be_clear
-    @data[1].should_not be_clear
+  it "should have correct debug name" do
+    subject[2].debug_name.should == "obj[2]"
   end
 
-  it "should symmetrically read and write" do
-    @data[1] = 8
-    str = @data.to_binary_s
-
-    @data.clear
-    @data[1].should == 2
-
-    @data.read(str)
-    @data[1].should == 8
+  it "should have correct offset" do
+    subject[2].offset.should == ExampleSingle.new.num_bytes * 2
   end
 
-  it "should identify index of elements" do
-    @data.index(3).should == 2
+  it "should have correct num_bytes" do
+    subject.num_bytes.should == 5 * ExampleSingle.new.num_bytes
   end
 
-  it "should return nil for index of non existent element" do
-    @data.index(42).should be_nil
+  it "should have 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
-  before(:each) do
+  subject {
     type = [:example_single, {:initial_value => lambda { index + 1 }}]
-    @data = BinData::Array.new(:type => type, :initial_length => 5)
-    @data[0] = 1
-    @data[1] = 2
-    @data[2] = 3
-    @data[3] = 4
-    @data[4] = 5
-  end
+    data = BinData::Array.new(:type => type, :initial_length => 5)
+    data.assign([1, 2, 3, 4, 5])
+    data
+  }
 
   it "should insert with positive indexes" do
-    @data.insert(2, 30, 40)
-    @data.snapshot.should == [1, 2, 30, 40, 3, 4, 5]
+    subject.insert(2, 30, 40)
+    subject.snapshot.should == [1, 2, 30, 40, 3, 4, 5]
   end
 
   it "should insert with negative indexes" do
-    @data.insert(-2, 30, 40)
-    @data.snapshot.should == [1, 2, 3, 4, 30, 40, 5]
+    subject.insert(-2, 30, 40)
+    subject.snapshot.should == [1, 2, 3, 4, 30, 40, 5]
   end
 
   it "should push" do
-    @data.push(30, 40)
-    @data.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
+    subject.push(30, 40)
+    subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
   end
 
   it "should concat" do
-    @data.concat([30, 40])
-    @data.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
+    subject.concat([30, 40])
+    subject.snapshot.should == [1, 2, 3, 4, 5, 30, 40]
   end
 
   it "should unshift" do
-    @data.unshift(30, 40)
-    @data.snapshot.should == [30, 40, 1, 2, 3, 4, 5]
+    subject.unshift(30, 40)
+    subject.snapshot.should == [30, 40, 1, 2, 3, 4, 5]
   end
 
   it "should automatically extend on [index]" do
-    @data[9].should == 10
-    @data.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    subject[9].should == 10
+    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   end
 
   it "should automatically extend on []=" do
-    @data[9] = 30
-    @data.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
+    subject[9] = 30
+    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 8, 9, 30]
   end
 
   it "should automatically extend on insert" do
-    @data.insert(7, 30, 40)
-    @data.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 30, 40]
+    subject.insert(7, 30, 40)
+    subject.snapshot.should == [1, 2, 3, 4, 5, 6, 7, 30, 40]
   end
 
   it "should not extend on at" do
-    @data.at(9).should be_nil
-    @data.length.should == 5
+    subject.at(9).should be_nil
+    subject.length.should == 5
   end
 
   it "should not extend on [start, length]" do
-    @data[9, 2].should be_nil
-    @data.length.should == 5
+    subject[9, 2].should be_nil
+    subject.length.should == 5
   end
 
   it "should not extend on [range]" do
-    @data[9 .. 10].should be_nil
-    @data.length.should == 5
+    subject[9 .. 10].should be_nil
+    subject.length.should == 5
   end
 
   it "should raise error on bad input to []" do
-    lambda { @data["a"] }.should raise_error(TypeError)
-    lambda { @data[1, "a"] }.should raise_error(TypeError)
+    lambda { subject["a"] }.should raise_error(TypeError)
+    lambda { subject[1, "a"] }.should raise_error(TypeError)
   end
 end
 
-describe BinData::Array, "with :read_until containing +element+" do
-  before(:each) do
-    read_until = lambda { element == 5 }
-    @data = BinData::Array.new(:type => :int8, :read_until => read_until)
-  end
+describe BinData::Array, "with :read_until" do
 
-  it "should read until the sentinel is reached" do
-    str = "\x01\x02\x03\x04\x05\x06\x07"
-    @data.read(str)
-    @data.length.should == 5
-  end
-end
+  context "containing +element+" do
+    it "should read until the sentinel is reached" do
+      read_until = lambda { element == 5 }
+      subject = BinData::Array.new(:type => :int8, :read_until => read_until)
 
-describe BinData::Array, "with :read_until containing +array+ and +index+" do
-  before(:each) do
-    read_until = lambda { index >= 2 and array[index - 2] == 5 }
-    @data = 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
 
-  it "should read until the sentinel is reached" do
-    str = "\x01\x02\x03\x04\x05\x06\x07\x08"
-    @data.read(str)
-    @data.length.should == 7
-  end
-end
+  context "containing +array+ and +index+" do
+    it "should read 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)
 
-describe BinData::Array, "with :read_until => :eof" do
-  it "should read records until eof" do
-    obj = BinData::Array.new(:type => :int8, :read_until => :eof)
-    str = "\x01\x02\x03"
-    obj.read(str)
-    obj.snapshot.should == [1, 2, 3]
+      subject.read "\x01\x02\x03\x04\x05\x06\x07\x08"
+      subject.should == [1, 2, 3, 4, 5, 6, 7]
+    end
   end
 
-  it "should read records until eof, ignoring partial records" do
-    obj = BinData::Array.new(:type => :int16be, :read_until => :eof)
-    str = "\x00\x01\x00\x02\x03"
-    obj.read(str)
-    obj.snapshot.should == [1, 2]
+  context "== :eof" do
+    it "should read 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 "should read 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
   end
 end
 
 describe BinData::Array, "nested within an Array" do
-  before(:each) do
+  subject {
     nested_array_params = { :type => [:int8, { :initial_value => :index }],
                             :initial_length => lambda { index + 1 } }
-    @data = BinData::Array.new(:type => [:array, nested_array_params],
-                               :initial_length => 3)
-  end
+    BinData::Array.new(:type => [:array, nested_array_params],
+                       :initial_length => 3)
+  }
 
-  it "should use correct index" do
-    @data.snapshot.should == [ [0], [0, 1], [0, 1, 2] ]
-  end
+  its(:snapshot) { should == [ [0], [0, 1], [0, 1, 2] ] }
 
   it "should maintain structure when reading" do
-    str = "\x04\x05\x06\x07\x08\x09"
-    @data.read(str)
-    @data.snapshot.should == [ [4], [5, 6], [7, 8, 9] ]
+    subject.read "\x04\x05\x06\x07\x08\x09"
+    subject.should == [ [4], [5, 6], [7, 8, 9] ]
   end
 end