bindata 0.6.0 → 0.7.0

data/spec/registry_spec.rb

@@ -3,16 +3,16 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/registry'
 
-context "The Registry" do
-  setup do
+describe "The Registry" do
+  before(:each) do
     @r = BinData::Registry.instance
   end
 
-  specify "should be a singleton" do
+  it "should be a singleton" do
     BinData::Registry.instance.should equal(BinData::Registry.instance)
   end
 
-  specify "should lookup registered names" do
+  it "should lookup registered names" do
     A = Class.new
     B = Class.new
     @r.register('ASubClass', A)
@@ -22,23 +22,23 @@ context "The Registry" do
     @r.lookup('another_sub_class').should eql(B)
   end
 
-  specify "should not lookup unregistered names" do
+  it "should not lookup unregistered names" do
     @r.lookup('a_non_existent_sub_class').should be_nil
   end
 
-  specify "should convert CamelCase to underscores" do
+  it "should convert CamelCase to underscores" do
     @r.register('CamelCase', A).should eql('camel_case')
   end
 
-  specify "should convert adjacent caps camelCase to underscores" do
+  it "should convert adjacent caps camelCase to underscores" do
     @r.register('XYZCamelCase', A).should eql('xyz_camel_case')
   end
 
-  specify "should ignore the outer nestings of classes" do
+  it "should ignore the outer nestings of classes" do
     @r.register('A::B::C', A).should eql('c')
   end
 
-  specify "should allow overriding of registered classes" do
+  it "should allow overriding of registered classes" do
     @r.register('A', A)
     @r.register('A', B)
 

data/spec/single_spec.rb

@@ -12,8 +12,8 @@ class ConcreteSingle < BinData::Single
   def in_read?()         @in_read end
 end
 
-context "The sample implementation of Single" do
-  specify "should have symmetric IO" do
+describe "The sample implementation of Single" do
+  it "should have symmetric IO" do
     io = StringIO.new
     data = ConcreteSingle.new
     data.value = 42
@@ -26,26 +26,26 @@ context "The sample implementation of Single" do
   end
 end
 
-context "The class Single" do
-  specify "should register subclasses" do
+describe "The class Single" do
+  it "should register subclasses" do
     BinData::Single.lookup(:concrete_single).should eql(ConcreteSingle)
   end
 
-  specify "should read and return a value" do
+  it "should read and return a value" do
     io = StringIO.new([123456].pack("V"))
     ConcreteSingle.read(io).should eql(123456)
     data = ConcreteSingle.new
   end
 end
 
-context "A Single object" do
-  specify "should conform to rule 1 for returning a value" do
+describe "A Single object" do
+  it "should conform to rule 1 for returning a value" do
     data = ConcreteSingle.new(:value => 5)
     data.should_not be_in_read
     data.value.should eql(5)
   end
 
-  specify "should conform to rule 2 for returning a value" do
+  it "should conform to rule 2 for returning a value" do
     io = StringIO.new([42].pack("V"))
     data = ConcreteSingle.new(:value => 5)
     data.do_read(io)
@@ -53,26 +53,26 @@ context "A Single object" do
     data.value.should eql(42)
   end
 
-  specify "should conform to rule 3 for returning a value" do
+  it "should conform to rule 3 for returning a value" do
     data = ConcreteSingle.new(:initial_value => 5)
     data.should be_clear
     data.value.should eql(5)
   end
 
-  specify "should conform to rule 4 for returning a value" do
+  it "should conform to rule 4 for returning a value" do
     data = ConcreteSingle.new(:initial_value => 5)
     data.value = 17
     data.should_not be_clear
     data.value.should eql(17)
   end
 
-  specify "should conform to rule 5 for returning a value" do
+  it "should conform to rule 5 for returning a value" do
     data = ConcreteSingle.new
     data.should be_clear
     data.value.should eql(0)
   end
 
-  specify "should conform to rule 6 for returning a value" do
+  it "should conform to rule 6 for returning a value" do
     data = ConcreteSingle.new
     data.value = 8
     data.should_not be_clear
@@ -80,130 +80,130 @@ context "A Single object" do
   end
 end
 
-context "A new Single object" do
-  setup do
+describe "A new Single object" do
+  before(:each) do
     @data = ConcreteSingle.new
   end
 
-  specify "should not allow both :initial_value and :value" do
+  it "should not allow both :initial_value and :value" do
     params = {:initial_value => 1, :value => 2}
     lambda { ConcreteSingle.new(params) }.should raise_error(ArgumentError)
   end
 
-  specify "should have a sensible value" do
+  it "should have a sensible value" do
     @data.value.should eql(0)
   end
 
-  specify "should allowing setting and retrieving value" do
+  it "should allowing setting and retrieving value" do
     @data.value = 5
     @data.value.should eql(5)
   end
 
-  specify "should be clear" do
+  it "should be clear" do
     @data.should be_clear
   end
 
-  specify "should not be clear after setting value" do
+  it "should not be clear after setting value" do
     @data.value = 5
     @data.should_not be_clear
   end
 
-  specify "should not be clear after reading" do
+  it "should not be clear after reading" do
     io = StringIO.new([123456].pack("V"))
     @data.read(io)
     @data.should_not be_clear
   end
 
-  specify "should return num_bytes" do
+  it "should return num_bytes" do
     @data.num_bytes.should eql(4)
   end
 
-  specify "should not contain any field names" do
+  it "should not contain any field names" do
     @data.field_names.should be_empty
   end
 
-  specify "should return a snapshot" do
+  it "should return a snapshot" do
     @data.value = 5
     @data.snapshot.should eql(5)
   end
 end
 
-context "A Single with :initial_value" do
-  setup do
+describe "A Single with :initial_value" do
+  before(:each) do
     @data = ConcreteSingle.new(:initial_value => 5)
   end
 
-  specify "should return that initial value before reading or being set" do
+  it "should return that initial value before reading or being set" do
     @data.value.should eql(5)
   end
 
-  specify "should forget :initial_value after being set" do
+  it "should forget :initial_value after being set" do
     @data.value = 17
     @data.value.should_not eql(5)
   end
 
-  specify "should forget :initial_value after reading" do
+  it "should forget :initial_value after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
     @data.value.should_not eql(5)
   end
 
-  specify "should remember :initial_value after being cleared" do
+  it "should remember :initial_value after being cleared" do
     @data.value = 17
     @data.clear
     @data.value.should eql(5)
   end
 end
 
-context "A Single with :value" do
-  setup do
+describe "A Single with :value" do
+  before(:each) do
     @data = ConcreteSingle.new(:value => 5)
   end
 
-  specify "should return that :value" do
+  it "should return that :value" do
     @data.value.should eql(5)
   end
 
-  specify "should change during reading" do
+  it "should change during reading" do
     io = StringIO.new([56].pack("V"))
     @data.do_read(io)
     @data.value.should eql(56)
     @data.done_read
   end
 
-  specify "should not change after reading" do
+  it "should not change after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
     @data.value.should eql(5)
   end
 
-  specify "should not be able to change the value" do
+  it "should not be able to change the value" do
     @data.value = 17
     @data.value.should eql(5)
   end
 end
 
-context "A Single with :check_value" do
-  setup do
+describe "A Single with :check_value" do
+  before(:each) do
     @io = StringIO.new([34].pack("V"))
   end
 
-  specify "should succeed when check_value is non boolean and correct" do
+  it "should succeed when check_value is non boolean and correct" do
     data = ConcreteSingle.new(:check_value => 34)
     lambda { data.read(@io) }.should_not raise_error
   end
 
-  specify "should fail when check_value is non boolean and incorrect" do
+  it "should fail when check_value is non boolean and incorrect" do
     data = ConcreteSingle.new(:check_value => lambda { 123 * 5 })
     lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
   end
 
-  specify "should succeed when check_value is boolean and true" do
+  it "should succeed when check_value is boolean and true" do
     data = ConcreteSingle.new(:check_value => lambda { (value % 2) == 0})
     lambda { data.read(@io) }.should_not raise_error
   end
 
-  specify "should fail when check_value is boolean and false" do
+  it "should fail when check_value is boolean and false" do
     data = ConcreteSingle.new(:check_value => lambda { value > 100 })
     lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
   end

data/spec/spec_common.rb

@@ -2,7 +2,7 @@ $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
 
 begin
   require 'rubygems'
-  gem 'rspec', '> 0.8.0'
+  gem 'rspec', '> 0.9.0'
 rescue LoadError
 end
 

data/spec/string_spec.rb

@@ -3,53 +3,53 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/string'
 
-context "Test mutual exclusion of parameters" do
-  specify ":value and :initial_value" do
+describe "Test mutual exclusion of parameters" do
+  it ":value and :initial_value" do
     params = {:value => "", :initial_value => ""}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 
-  specify ":length and :initial_length" do
+  it ":length and :initial_length" do
     params = {:length => 5, :initial_length => 5}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 
-  specify ":initial_value and :initial_length" do
+  it ":initial_value and :initial_length" do
     params = {:initial_value => "", :initial_length => 5}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 
-  specify ":value and :length" do
+  it ":value and :length" do
     params = {:value => "", :length => 5}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 end
 
-context "A String with :initial_length" do
-  setup do
+describe "A String with :initial_length" do
+  before(:each) do
     @str = BinData::String.new(:initial_length => 5)
   end
 
-  specify "should set num_bytes" do
+  it "should set num_bytes" do
     @str.num_bytes.should eql(5)
   end
 
-  specify "should fill value with pad_char" do
+  it "should fill value with pad_char" do
     @str.value.should eql("\0\0\0\0\0")
   end
 
-  specify "should read :initial_length bytes" do
+  it "should read :initial_length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
     @str.value.should eql("abcde")
   end
 
-  specify "should forget :initial_length after value is set" do
+  it "should forget :initial_length after value is set" do
     @str.value = "abc"
     @str.num_bytes.should eql(3)
   end
 
-  specify "should remember :initial_length after value is cleared" do
+  it "should remember :initial_length after value is cleared" do
     @str.value = "abc"
     @str.num_bytes.should eql(3)
     @str.clear
@@ -57,70 +57,70 @@ context "A String with :initial_length" do
   end
 end
 
-context "A String with :length" do
-  setup do
+describe "A String with :length" do
+  before(:each) do
     @str = BinData::String.new(:length => 5)
   end
 
-  specify "should set num_bytes" do
+  it "should set num_bytes" do
     @str.num_bytes.should eql(5)
   end
 
-  specify "should fill value with pad_char" do
+  it "should fill value with pad_char" do
     @str.value.should eql("\0\0\0\0\0")
   end
 
-  specify "should retain :length after value is set" do
+  it "should retain :length after value is set" do
     @str.value = "abcdefghij"
     @str.num_bytes.should eql(5)
   end
 
-  specify "should read :length bytes" do
+  it "should read :length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
     @str.value.should eql("abcde")
   end
 
-  specify "should pad values less than :length" do
+  it "should pad values less than :length" do
     @str.value = "abc"
     @str.value.should eql("abc\0\0")
   end
 
-  specify "should accept values exactly :length" do
+  it "should accept values exactly :length" do
     @str.value = "abcde"
     @str.value.should eql("abcde")
   end
 
-  specify "should truncate values greater than :length" do
+  it "should truncate values greater than :length" do
     @str.value = "abcdefg"
     @str.value.should eql("abcde")
   end
 end
 
-context "A String with :initial_length and :value" do
-  setup do
+describe "A String with :initial_length and :value" do
+  before(:each) do
     @str = BinData::String.new(:initial_length => 5, :value => "abcdefghij")
   end
 
-  specify "should use :initial_length before value is read" do
+  it "should use :initial_length before value is read" do
     @str.num_bytes.should eql(5)
     @str.value.should eql("abcde")
   end
 
-  specify "should use :initial_length for reading" do
+  it "should use :initial_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
     io.pos.should eql(5)
    end
 
-  specify "should forget :initial_length after reading" do
+  it "should forget :initial_length after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
     @str.num_bytes.should eql(10)
     @str.value.should eql("abcdefghij")
   end
 
-  specify "should return read value before calling done_read" do
+  it "should return read value before calling done_read" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
 
     @str.do_read(io)
@@ -131,17 +131,17 @@ context "A String with :initial_length and :value" do
   end
 end
 
-context "A String with :length and :initial_value" do
-  setup do
+describe "A String with :length and :initial_value" do
+  before(:each) do
     @str = BinData::String.new(:length => 5, :initial_value => "abcdefghij")
   end
 
-  specify "should apply :length to :initial_value" do
+  it "should apply :length to :initial_value" do
     @str.num_bytes.should eql(5)
     @str.value.should eql("abcde")
   end
 
-  specify "should forget :initial_value after reading" do
+  it "should forget :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
     io.pos.should eql(5)
@@ -150,27 +150,27 @@ context "A String with :length and :initial_value" do
   end
 end
 
-context "A String with :pad_char" do
-  specify "should accept a numeric value for :pad_char" do
+describe "A String with :pad_char" do
+  it "should accept a numeric value for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => 6)
     @str.value = "abc"
     @str.value.should eql("abc\x06\x06")
   end
 
-  specify "should accept a character for :pad_char" do
+  it "should accept a character for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => "R")
     @str.value = "abc"
     @str.value.should eql("abcRR")
   end
 
-  specify "should not accept a string for :pad_char" do
+  it "should not accept a string for :pad_char" do
     params = {:length => 5, :pad_char => "RR"}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 end
 
-context "A String with :trim_value" do
-  specify "set false is the default" do
+describe "A String with :trim_value" do
+  it "set false is the default" do
     str1 = BinData::String.new(:length => 5)
     str2 = BinData::String.new(:length => 5, :trim_value => false)
     str1.value = "abc"
@@ -179,25 +179,25 @@ context "A String with :trim_value" do
     str2.value.should eql("abc\0\0")
   end
 
-  specify "should trim the value" do
+  it "should trim the value" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
     str.value.should eql("abc")
   end
 
-  specify "should not affect num_bytes" do
+  it "should not affect num_bytes" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
     str.num_bytes.should eql(5)
   end
 
-  specify "should trim if last char is :pad_char" do
+  it "should trim if last char is :pad_char" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
     str.value.should eql("abc")
   end
 
-  specify "should not trim if value contains :pad_char not at the end" do
+  it "should not trim if value contains :pad_char not at the end" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRRde"
     str.value.should eql("abcRRde")