bindata 1.2.2 → 1.3.1

data/spec/deprecated_spec.rb

@@ -23,6 +23,30 @@ describe BinData::MultiValue, "when defining" do
 end
 
 describe BinData::Base, "when defining" do
+  it "should fail if #initialize is overridden" do
+    class BaseWithInitialize < BinData::Base
+      def initialize(params = {}, parent = nil)
+        super
+      end
+    end
+
+    lambda {
+      BaseWithInitialize.new
+    }.should raise_error
+  end
+
+  it "should handle if #initialize is naively renamed to #initialize_instance" do
+    class BaseWithInitializeInstance < BinData::Base
+      def initialize_instance(params = {}, parent = nil)
+        super
+      end
+    end
+
+    lambda {
+      BaseWithInitializeInstance.new
+    }.should_not raise_error
+  end
+
   it "should handle deprecated #register method" do
     lambda {
       class DeprecatedRegisterBase < BinData::Base
@@ -57,34 +81,32 @@ describe BinData::Base do
   class DeprecatedBase < BinData::Base
   end
 
-  before(:each) do
-    @obj = DeprecatedBase.new
-    @io = "abcde"
-  end
+  subject { DeprecatedBase.new }
+  let(:io)  { "abcde" }
 
   it "should forward _do_read to do_read" do
-    @obj.should_receive(:do_read).with(@io)
-    @obj._do_read(@io)
+    subject.should_receive(:do_read).with(io)
+    subject._do_read(io)
   end
 
   it "should forward _do_write to do_write" do
-    @obj.should_receive(:do_write).with(@io)
-    @obj._do_write(@io)
+    subject.should_receive(:do_write).with(io)
+    subject._do_write(io)
   end
 
   it "should forward _do_num_bytes to do_num_bytes" do
-    @obj.should_receive(:do_num_bytes)
-    @obj._do_num_bytes
+    subject.should_receive(:do_num_bytes)
+    subject._do_num_bytes
   end
 
   it "should forward _assign to assign" do
     val = 3
-    @obj.should_receive(:assign).with(val)
-    @obj._assign(val)
+    subject.should_receive(:assign).with(val)
+    subject._assign(val)
   end
 
   it "should forward _snapshot to snapshot" do
-    @obj.should_receive(:snapshot)
-    @obj._snapshot
+    subject.should_receive(:snapshot)
+    subject._snapshot
   end
 end

data/spec/float_spec.rb

@@ -4,86 +4,34 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/float'
 
 describe "A FloatLe" do
-  before(:each) do
-    @obj = BinData::FloatLe.new
-    @obj.value = Math::PI
-  end
+  subject { BinData::FloatLe.new(Math::PI) }
 
-  it "should be 4 bytes in size" do
-    @obj.num_bytes.should == 4
-  end
-
-  it "should write the expected value" do
-    written_value(@obj).should == [Math::PI].pack('e')
-  end
-
-  it "should read the same value as written" do
-    value_read_from_written(@obj).should be_close(Math::PI, 0.000001)
-  end
+  its(:num_bytes) { should == 4 }
+  its(:to_binary_s) { should == [Math::PI].pack('e') }
+  its(:value_read_from_written) { should be_close(Math::PI, 0.000001) }
 end
 
 describe "A FloatBe" do
-  before(:each) do
-    @obj = BinData::FloatBe.new
-    @obj.value = Math::PI
-  end
-
-  it "should be 4 bytes in size" do
-    @obj.num_bytes.should == 4
-  end
+  subject { BinData::FloatBe.new(Math::PI) }
 
-  it "should write the expected value" do
-    written_value(@obj).should == [Math::PI].pack('g')
-  end
-
-  it "should read the same value as written" do
-    value_read_from_written(@obj).should be_close(Math::PI, 0.000001)
-  end
+  its(:num_bytes) { should == 4 }
+  its(:to_binary_s) { should == [Math::PI].pack('g') }
+  its(:value_read_from_written) { should be_close(Math::PI, 0.000001) }
 end
 
 describe "A DoubleLe" do
-  before(:each) do
-    @obj = BinData::DoubleLe.new
-    @obj.value = Math::PI
-  end
-
-  it "should be 8 bytes in size" do
-    @obj.num_bytes.should == 8
-  end
-
-  it "should write the expected value" do
-    written_value(@obj).should == [Math::PI].pack('E')
-  end
+  subject { BinData::DoubleLe.new(Math::PI) }
 
-  it "should read the same value as written" do
-    value_read_from_written(@obj).should be_close(Math::PI, 0.0000000000000001)
-  end
+  its(:num_bytes) { should == 8 }
+  its(:to_binary_s) { should == [Math::PI].pack('E') }
+  its(:value_read_from_written) { should be_close(Math::PI, 0.0000000000000001) }
 end
 
 
 describe "A DoubleBe" do
-  before(:each) do
-    @obj = BinData::DoubleBe.new
-    @obj.value = Math::PI
-  end
-
-  it "should be 8 bytes in size" do
-    @obj.num_bytes.should == 8
-  end
-
-  it "should write the expected value" do
-    written_value(@obj).should == [Math::PI].pack('G')
-  end
-
-  it "should read the same value as written" do
-    value_read_from_written(@obj).should be_close(Math::PI, 0.0000000000000001)
-  end
-end
-
-def written_value(obj)
-  obj.to_binary_s
-end
+  subject { BinData::DoubleBe.new(Math::PI) }
 
-def value_read_from_written(obj)
-  obj.class.read(obj.to_binary_s)
+  its(:num_bytes) { should == 8 }
+  its(:to_binary_s) { should == [Math::PI].pack('G') }
+  its(:value_read_from_written) { should be_close(Math::PI, 0.0000000000000001) }
 end

data/spec/int_spec.rb

@@ -13,34 +13,35 @@ share_examples_for "All Integers" do
 
   it "should have a sensible value of zero" do
     all_classes do |int_class|
-      int_class.new.value.should be_zero
+      int_class.new.should be_zero
     end
   end
 
   it "should avoid underflow" do
     all_classes do |int_class|
-      obj = int_class.new
-      obj.value = min_value - 1
+      subject = int_class.new
+      subject.assign(min_value - 1)
 
-      obj.value.should == min_value
+      subject.should == min_value
     end
   end
 
   it "should avoid overflow" do
     all_classes do |int_class|
-      obj = int_class.new
-      obj.value = max_value + 1
+      subject = int_class.new
+      subject.assign(max_value + 1)
 
-      obj.value.should == max_value
+      subject.should == max_value
     end
   end
 
   it "should assign values" do
     all_classes do |int_class|
-      obj = int_class.new
+      subject = int_class.new
       test_int = gen_test_int
-      obj.assign(test_int)
-      obj.value.should == test_int
+      subject.assign(test_int)
+
+      subject.should == test_int
     end
   end
 
@@ -49,30 +50,28 @@ share_examples_for "All Integers" do
       src = int_class.new
       src.assign(gen_test_int)
 
-      obj = int_class.new
-      obj.assign(src)
-      obj.value.should == src.value
+      subject = int_class.new
+      subject.assign(src)
+      subject.should == src
     end
   end
 
   it "should symmetrically read and write a +ve number" do
     all_classes do |int_class|
-      obj = int_class.new
-      obj.value = gen_test_int
+      subject = int_class.new
+      subject.assign(gen_test_int)
 
-      str = obj.to_binary_s
-      int_class.read(str).should == obj.value
+      subject.value_read_from_written.should == subject
     end
   end
 
   it "should symmetrically read and write a -ve number" do
     all_classes do |int_class|
       if @signed
-        obj = int_class.new
-        obj.value = -gen_test_int
+        subject = int_class.new
+        subject.assign(-gen_test_int)
 
-        str = obj.to_binary_s
-        int_class.read(str).should == obj.value
+        subject.value_read_from_written.should == subject
       end
     end
   end
@@ -81,10 +80,10 @@ share_examples_for "All Integers" do
     all_classes do |int_class|
       val = gen_test_int
 
-      obj = int_class.new
-      obj.value = val
+      subject = int_class.new
+      subject.assign(val)
 
-      obj.to_binary_s.should == int_to_binary_str(val)
+      subject.to_binary_s.should == int_to_binary_str(val)
     end
   end
 
@@ -93,10 +92,10 @@ share_examples_for "All Integers" do
       if @signed
         val = -gen_test_int
 
-        obj = int_class.new
-        obj.value = val
+        subject = int_class.new
+        subject.assign(val)
 
-        obj.to_binary_s.should == int_to_binary_str(val)
+        subject.to_binary_s.should == int_to_binary_str(val)
       end
     end
   end

data/spec/io_spec.rb

@@ -41,52 +41,42 @@ describe BinData::IO, "reading from non seekable stream" do
   end
 end
 
-describe BinData::IO do
+describe BinData::IO, "when reading" do
+  let(:stream) { StringIO.new "abcdefghij" }
+  let(:io) { BinData::IO.new(stream) }
+
   it "should wrap strings in StringIO" do
-    io = BinData::IO.new("abcd")
     io.raw_io.class.should == StringIO
   end
 
   it "should not wrap IO objects" do
-    stream = StringIO.new
-    io = BinData::IO.new(stream)
     io.raw_io.should == stream
   end
 
   it "should raise error when io is BinData::IO" do
     lambda {
-      io = BinData::IO.new(BinData::IO.new(""))
+      BinData::IO.new(BinData::IO.new(""))
     }.should raise_error(ArgumentError)
   end
 
   it "should return correct offset" do
-    stream = StringIO.new("abcdefghij")
     stream.seek(3, IO::SEEK_CUR)
 
-    io = BinData::IO.new(stream)
     io.offset.should == 0
-    io.readbytes(4)
+    io.readbytes(4).should == "defg"
     io.offset.should == 4
   end
 
   it "should seek" do
-    stream = StringIO.new("abcdefghij")
-    io = BinData::IO.new(stream)
-
     io.seekbytes(2)
     io.readbytes(4).should == "cdef"
   end
 
   it "should read all bytes" do
-    stream = StringIO.new("abcdefghij")
-    io = BinData::IO.new(stream)
-
     io.read_all_bytes.should == "abcdefghij"
   end
 
   it "should raise error when reading at eof" do
-    stream = StringIO.new("abcdefghij")
-    io = BinData::IO.new(stream)
     io.seekbytes(10)
     lambda {
       io.readbytes(3)
@@ -94,115 +84,129 @@ describe BinData::IO do
   end
 
   it "should raise error on short reads" do
-    stream = StringIO.new("abcdefghij")
-    io = BinData::IO.new(stream)
     lambda {
       io.readbytes(20)
     }.should raise_error(IOError)
   end
+end
+
+describe BinData::IO, "when writing" do
+  let(:stream) { StringIO.new }
+  let(:io) { BinData::IO.new(stream) }
+
+  it "should not wrap IO objects" do
+    io.raw_io.should == stream
+  end
+
+  it "should raise error when io is BinData::IO" do
+    lambda {
+      BinData::IO.new(BinData::IO.new(""))
+    }.should raise_error(ArgumentError)
+  end
 
   it "should write" do
-    stream = StringIO.new
-    io = BinData::IO.new(stream)
     io.writebytes("abcd")
 
     stream.value.should == "abcd"
   end
 
   it "should flush" do
-    stream = StringIO.new
-    io = BinData::IO.new(stream)
     io.writebytes("abcd")
     io.flush
 
     stream.value.should == "abcd"
   end
-
 end
 
 describe BinData::IO, "reading bits in big endian" do
-  before(:each) do
-    @b1 = 0b1111_1010
-    @b2 = 0b1100_1110
-    @b3 = 0b0110_1010
-    str = [@b1, @b2, @b3].pack("CCC")
-    @io = BinData::IO.new(str)
-  end
+  let(:b1) { 0b1111_1010 }
+  let(:b2) { 0b1100_1110 }
+  let(:b3) { 0b0110_1010 }
+  let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
 
   it "should read a bitfield less than 1 byte" do
-    @io.readbits(3, :big).should == 0b111
+    io.readbits(3, :big).should == 0b111
   end
 
   it "should read a bitfield more than 1 byte" do
-    @io.readbits(10, :big).should == 0b1111_1010_11
+    io.readbits(10, :big).should == 0b1111_1010_11
   end
 
   it "should read a bitfield more than 2 bytes" do
-    @io.readbits(17, :big).should == 0b1111_1010_1100_1110_0
+    io.readbits(17, :big).should == 0b1111_1010_1100_1110_0
   end
 
   it "should read two bitfields totalling less than 1 byte" do
-    @io.readbits(5, :big).should == 0b1111_1
-    @io.readbits(2, :big).should == 0b01
+    io.readbits(5, :big).should == 0b1111_1
+    io.readbits(2, :big).should == 0b01
   end
 
   it "should read two bitfields totalling more than 1 byte" do
-    @io.readbits(6, :big).should == 0b1111_10
-    @io.readbits(8, :big).should == 0b10_1100_11
+    io.readbits(6, :big).should == 0b1111_10
+    io.readbits(8, :big).should == 0b10_1100_11
   end
 
   it "should read two bitfields totalling more than 2 bytes" do
-    @io.readbits(7, :big).should == 0b1111_101
-    @io.readbits(12, :big).should == 0b0_1100_1110_011
+    io.readbits(7, :big).should == 0b1111_101
+    io.readbits(12, :big).should == 0b0_1100_1110_011
   end
 
   it "should ignore unused bits when reading bytes" do
-    @io.readbits(3, :big).should == 0b111
-    @io.readbytes(1).should == [@b2].pack("C")
-    @io.readbits(2, :big).should == 0b01
+    io.readbits(3, :big).should == 0b111
+    io.readbytes(1).should == [b2].pack("C")
+    io.readbits(2, :big).should == 0b01
+  end
+
+  it "should reset read bits to realign stream to next byte" do
+    io.readbits(3, :big).should == 0b111
+    io.reset_read_bits
+    io.readbits(3, :big).should == 0b110
   end
 end
 
 describe BinData::IO, "reading bits in little endian" do
-  before(:each) do
-    @b1 = 0b1111_1010
-    @b2 = 0b1100_1110
-    @b3 = 0b0110_1010
-    str = [@b1, @b2, @b3].pack("CCC")
-    @io = BinData::IO.new(str)
-  end
+  let(:b1) { 0b1111_1010 }
+  let(:b2) { 0b1100_1110 }
+  let(:b3) { 0b0110_1010 }
+  let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
 
   it "should read a bitfield less than 1 byte" do
-    @io.readbits(3, :little).should == 0b010
+    io.readbits(3, :little).should == 0b010
   end
 
   it "should read a bitfield more than 1 byte" do
-    @io.readbits(10, :little).should == 0b10_1111_1010
+    io.readbits(10, :little).should == 0b10_1111_1010
   end
 
   it "should read a bitfield more than 2 bytes" do
-    @io.readbits(17, :little).should == 0b0_1100_1110_1111_1010
+    io.readbits(17, :little).should == 0b0_1100_1110_1111_1010
   end
 
   it "should read two bitfields totalling less than 1 byte" do
-    @io.readbits(5, :little).should == 0b1_1010
-    @io.readbits(2, :little).should == 0b11
+    io.readbits(5, :little).should == 0b1_1010
+    io.readbits(2, :little).should == 0b11
   end
 
   it "should read two bitfields totalling more than 1 byte" do
-    @io.readbits(6, :little).should == 0b11_1010
-    @io.readbits(8, :little).should == 0b00_1110_11
+    io.readbits(6, :little).should == 0b11_1010
+    io.readbits(8, :little).should == 0b00_1110_11
   end
 
   it "should read two bitfields totalling more than 2 bytes" do
-    @io.readbits(7, :little).should == 0b111_1010
-    @io.readbits(12, :little).should == 0b010_1100_1110_1
+    io.readbits(7, :little).should == 0b111_1010
+    io.readbits(12, :little).should == 0b010_1100_1110_1
   end
 
   it "should ignore unused bits when reading bytes" do
-    @io.readbits(3, :little).should == 0b010
-    @io.readbytes(1).should == [@b2].pack("C")
-    @io.readbits(2, :little).should == 0b10
+    io.readbits(3, :little).should == 0b010
+    io.readbytes(1).should == [b2].pack("C")
+    io.readbits(2, :little).should == 0b10
+  end
+
+  it "should reset read bits to realign stream to next byte" do
+    io.readbits(3, :little).should == 0b010
+    io.reset_read_bits
+    io.readbits(3, :little).should == 0b110
   end
 end
 
@@ -228,96 +232,92 @@ class BitWriterHelper
 end
 
 describe BinData::IO, "writing bits in big endian" do
-  before(:each) do
-    @io = BitWriterHelper.new
-  end
+  let(:io) { BitWriterHelper.new }
 
   it "should write a bitfield less than 1 byte" do
-    @io.writebits(0b010, 3, :big)
-    @io.value.should == [0b0100_0000].pack("C")
+    io.writebits(0b010, 3, :big)
+    io.value.should == [0b0100_0000].pack("C")
   end
 
   it "should write a bitfield more than 1 byte" do
-    @io.writebits(0b10_1001_1101, 10, :big)
-    @io.value.should == [0b1010_0111, 0b0100_0000].pack("CC")
+    io.writebits(0b10_1001_1101, 10, :big)
+    io.value.should == [0b1010_0111, 0b0100_0000].pack("CC")
   end
 
   it "should write a bitfield more than 2 bytes" do
-    @io.writebits(0b101_1000_0010_1001_1101, 19, :big)
-    @io.value.should == [0b1011_0000, 0b0101_0011, 0b1010_0000].pack("CCC")
+    io.writebits(0b101_1000_0010_1001_1101, 19, :big)
+    io.value.should == [0b1011_0000, 0b0101_0011, 0b1010_0000].pack("CCC")
   end
 
   it "should write two bitfields totalling less than 1 byte" do
-    @io.writebits(0b1_1001, 5, :big)
-    @io.writebits(0b00, 2, :big)
-    @io.value.should == [0b1100_1000].pack("C")
+    io.writebits(0b1_1001, 5, :big)
+    io.writebits(0b00, 2, :big)
+    io.value.should == [0b1100_1000].pack("C")
   end
 
   it "should write two bitfields totalling more than 1 byte" do
-    @io.writebits(0b01_0101, 6, :big)
-    @io.writebits(0b001_1001, 7, :big)
-    @io.value.should == [0b0101_0100, 0b1100_1000].pack("CC")
+    io.writebits(0b01_0101, 6, :big)
+    io.writebits(0b001_1001, 7, :big)
+    io.value.should == [0b0101_0100, 0b1100_1000].pack("CC")
   end
 
   it "should write two bitfields totalling more than 2 bytes" do
-    @io.writebits(0b01_0111, 6, :big)
-    @io.writebits(0b1_0010_1001_1001, 13, :big)
-    @io.value.should == [0b0101_1110, 0b0101_0011, 0b0010_0000].pack("CCC")
+    io.writebits(0b01_0111, 6, :big)
+    io.writebits(0b1_0010_1001_1001, 13, :big)
+    io.value.should == [0b0101_1110, 0b0101_0011, 0b0010_0000].pack("CCC")
   end
 
   it "should pad unused bits when writing bytes" do
-    @io.writebits(0b101, 3, :big)
-    @io.writebytes([0b1011_1111].pack("C"))
-    @io.writebits(0b01, 2, :big)
+    io.writebits(0b101, 3, :big)
+    io.writebytes([0b1011_1111].pack("C"))
+    io.writebits(0b01, 2, :big)
 
-    @io.value.should == [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
+    io.value.should == [0b1010_0000, 0b1011_1111, 0b0100_0000].pack("CCC")
   end
 end
 
 describe BinData::IO, "writing bits in little endian" do
-  before(:each) do
-    @io = BitWriterHelper.new
-  end
+  let(:io) { BitWriterHelper.new }
 
   it "should write a bitfield less than 1 byte" do
-    @io.writebits(0b010, 3, :little)
-    @io.value.should == [0b0000_0010].pack("C")
+    io.writebits(0b010, 3, :little)
+    io.value.should == [0b0000_0010].pack("C")
   end
 
   it "should write a bitfield more than 1 byte" do
-    @io.writebits(0b10_1001_1101, 10, :little)
-    @io.value.should == [0b1001_1101, 0b0000_0010].pack("CC")
+    io.writebits(0b10_1001_1101, 10, :little)
+    io.value.should == [0b1001_1101, 0b0000_0010].pack("CC")
   end
 
   it "should write a bitfield more than 2 bytes" do
-    @io.writebits(0b101_1000_0010_1001_1101, 19, :little)
-    @io.value.should == [0b1001_1101, 0b1000_0010, 0b0000_0101].pack("CCC")
+    io.writebits(0b101_1000_0010_1001_1101, 19, :little)
+    io.value.should == [0b1001_1101, 0b1000_0010, 0b0000_0101].pack("CCC")
   end
 
   it "should write two bitfields totalling less than 1 byte" do
-    @io.writebits(0b1_1001, 5, :little)
-    @io.writebits(0b00, 2, :little)
-    @io.value.should == [0b0001_1001].pack("C")
+    io.writebits(0b1_1001, 5, :little)
+    io.writebits(0b00, 2, :little)
+    io.value.should == [0b0001_1001].pack("C")
   end
 
   it "should write two bitfields totalling more than 1 byte" do
-    @io.writebits(0b01_0101, 6, :little)
-    @io.writebits(0b001_1001, 7, :little)
-    @io.value.should == [0b0101_0101, 0b0000_0110].pack("CC")
+    io.writebits(0b01_0101, 6, :little)
+    io.writebits(0b001_1001, 7, :little)
+    io.value.should == [0b0101_0101, 0b0000_0110].pack("CC")
   end
 
   it "should write two bitfields totalling more than 2 bytes" do
-    @io.writebits(0b01_0111, 6, :little)
-    @io.writebits(0b1_0010_1001_1001, 13, :little)
-    @io.value.should == [0b0101_0111, 0b1010_0110, 0b0000_0100].pack("CCC")
+    io.writebits(0b01_0111, 6, :little)
+    io.writebits(0b1_0010_1001_1001, 13, :little)
+    io.value.should == [0b0101_0111, 0b1010_0110, 0b0000_0100].pack("CCC")
   end
 
   it "should pad unused bits when writing bytes" do
-    @io.writebits(0b101, 3, :little)
-    @io.writebytes([0b1011_1111].pack("C"))
-    @io.writebits(0b01, 2, :little)
+    io.writebits(0b101, 3, :little)
+    io.writebytes([0b1011_1111].pack("C"))
+    io.writebits(0b01, 2, :little)
 
-    @io.value.should == [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
+    io.value.should == [0b0000_0101, 0b1011_1111, 0b0000_0001].pack("CCC")
   end
 end