bindata 1.4.3 → 1.4.4

data/spec/registry_spec.rb

@@ -14,7 +14,7 @@ describe BinData::Registry do
 
   let(:r) { BinData::Registry.new }
 
-  it "should lookup registered names" do
+  it "lookups registered names" do
     r.register('ASubClass', A)
     r.register('AnotherSubClass', B)
 
@@ -24,37 +24,37 @@ describe BinData::Registry do
     r.lookup('another_sub_class').should == B
   end
 
-  it "should not lookup unregistered names" do
-    lambda {
+  it "does not lookup unregistered names" do
+    expect {
       r.lookup('a_non_existent_sub_class')
-    }.should raise_error(BinData::UnRegisteredTypeError)
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should be able to unregister names" do
+  it "unregisters names" do
     r.register('ASubClass', A)
     r.unregister('ASubClass')
 
-    lambda {
+    expect {
       r.lookup('ASubClass')
-    }.should raise_error(BinData::UnRegisteredTypeError)
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should allow overriding of registered classes" do
+  it "allows overriding of registered classes" do
     r.register('A', A)
     r.register('A', B)
 
     r.lookup('a').should == B
   end
 
-  it "should convert CamelCase to underscores" do
+  it "converts CamelCase to underscores" do
     r.underscore_name('CamelCase').should == 'camel_case'
   end
 
-  it "should convert adjacent caps camelCase to underscores" do
+  it "converts adjacent caps camelCase to underscores" do
     r.underscore_name('XYZCamelCase').should == 'xyz_camel_case'
   end
 
-  it "should ignore the outer nestings of classes" do
+  it "ignores the outer nestings of classes" do
     r.underscore_name('A::B::C').should == 'c'
   end
 end
@@ -62,44 +62,44 @@ end
 describe BinData::Registry, "with numerics" do
   let(:r) { BinData::RegisteredClasses }
 
-  it "should lookup integers with endian" do
+  it "lookup integers with endian" do
     r.lookup("int24", :big).to_s.should == "BinData::Int24be"
     r.lookup("int24", :little).to_s.should == "BinData::Int24le"
     r.lookup("uint24", :big).to_s.should == "BinData::Uint24be"
     r.lookup("uint24", :little).to_s.should == "BinData::Uint24le"
   end
 
-  it "should not lookup integers without endian" do
-    lambda {
+  it "does not lookup integers without endian" do
+    expect {
       r.lookup("int24")
-    }.should raise_error(BinData::UnRegisteredTypeError)
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should not lookup non byte based integers" do
-    lambda {
+  it "does not lookup non byte based integers" do
+    expect {
       r.lookup("int3")
-    }.should raise_error(BinData::UnRegisteredTypeError)
-    lambda {
+    }.to raise_error(BinData::UnRegisteredTypeError)
+    expect {
       r.lookup("int3", :big)
-    }.should raise_error(BinData::UnRegisteredTypeError)
-    lambda {
+    }.to raise_error(BinData::UnRegisteredTypeError)
+    expect {
       r.lookup("int3", :little)
-    }.should raise_error(BinData::UnRegisteredTypeError)
+    }.to raise_error(BinData::UnRegisteredTypeError)
   end
 
-  it "should lookup floats with endian" do
+  it "lookup floats with endian" do
     r.lookup("float", :big).to_s.should == "BinData::FloatBe"
     r.lookup("float", :little).to_s.should == "BinData::FloatLe"
     r.lookup("double", :big).to_s.should == "BinData::DoubleBe"
     r.lookup("double", :little).to_s.should == "BinData::DoubleLe"
   end
 
-  it "should lookup bits" do
+  it "lookup bits" do
     r.lookup("bit5").to_s.should == "BinData::Bit5"
     r.lookup("bit6le").to_s.should == "BinData::Bit6le"
   end
 
-  it "should lookup bits by ignoring endian" do
+  it "lookup bits by ignoring endian" do
     r.lookup("bit2", :big).to_s.should == "BinData::Bit2"
     r.lookup("bit3le", :big).to_s.should == "BinData::Bit3le"
     r.lookup("bit2", :little).to_s.should == "BinData::Bit2"

data/spec/rest_spec.rb

@@ -6,21 +6,21 @@ require 'bindata/rest'
 describe BinData::Rest do
   it { should == "" }
 
-  it "should read till end of stream" do
+  it "reads till end of stream" do
     data = "abcdefghij"
     subject.read(data).should == data
   end
 
-  it "should allow setting value for completeness" do
+  it "allows setting value for completeness" do
     subject.assign("123")
     subject.should == "123"
     subject.to_binary_s.should == "123"
   end
 
-  it "should accept BinData::BasePrimitive parameters" do
+  it "accepts BinData::BasePrimitive parameters" do
     rest = BinData::Rest.new(:check_value => "abc")
-    lambda {
+    expect {
       rest.read("xyz")
-    }.should raise_error(BinData::ValidityError)
+    }.to raise_error(BinData::ValidityError)
   end
 end

data/spec/skip_spec.rb

@@ -10,17 +10,17 @@ describe BinData::Skip do
   it { should == "" }
   its(:to_binary_s) { should == "\000" * 5 }
 
-  it "should skip bytes" do
+  it "skips bytes" do
     subject.read(io)
     io.pos.should == 5
   end
 
-  it "should have expected binary representation after setting value" do
+  it "has expected binary representation after setting value" do
     subject.assign("123")
     subject.to_binary_s.should == "\000" * 5
   end
 
-  it "should have expected binary representation after reading" do
+  it "has expected binary representation after reading" do
     subject.read(io)
     subject.to_binary_s.should == "\000" * 5
   end

data/spec/spec_common.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
 
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
+require 'rspec/autorun'
 require 'stringio'
 
 class Object

data/spec/string_spec.rb

@@ -7,30 +7,30 @@ require 'bindata/string'
 describe BinData::String, "with mutually exclusive parameters" do
   it ":value and :initial_value" do
     params = {:value => "", :initial_value => ""}
-    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+    expect { BinData::String.new(params) }.to raise_error(ArgumentError)
   end
 
   it ":length and :read_length" do
     params = {:length => 5, :read_length => 5}
-    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+    expect { BinData::String.new(params) }.to raise_error(ArgumentError)
   end
 
   it ":value and :length" do
     params = {:value => "", :length => 5}
-    lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
+    expect { BinData::String.new(params) }.to raise_error(ArgumentError)
   end
 end
 
 describe BinData::String, "when assigning" do
-  let(:small) { BinData::String.new(:length => 3, :pad_char => "A") }
-  let(:large) { BinData::String.new(:length => 5, :pad_char => "B") }
+  let(:small) { BinData::String.new(:length => 3, :pad_byte => "A") }
+  let(:large) { BinData::String.new(:length => 5, :pad_byte => "B") }
 
-  it "should copy data from small to large" do
+  it "copies data from small to large" do
     large.assign(small)
     large.should == "AAABB"
   end
 
-  it "should copy data from large to small" do
+  it "copies data from large to small" do
     small.assign(large)
     small.should == "BBB"
   end
@@ -39,11 +39,11 @@ end
 describe BinData::String do
   subject { BinData::String.new("testing") }
 
-  it "should compare with regexp" do
+  it "compares with regexp" do
     (/es/ =~ subject).should == 1
   end
 
-  it "should compare with regexp" do
+  it "compares with regexp" do
     (subject =~ /es/).should == 1
   end
 end
@@ -54,12 +54,12 @@ describe BinData::String, "with :read_length" do
   its(:num_bytes) { should == 0 }
   its(:value) { should == "" }
 
-  it "should read :read_length bytes" do
+  it "reads :read_length bytes" do
     subject.read("abcdefghij")
     subject.should == "abcde"
   end
 
-  it "should remember :read_length after value is cleared" do
+  it "remembers :read_length after value is cleared" do
     subject.assign("abc")
     subject.num_bytes.should == 3
     subject.clear
@@ -75,27 +75,27 @@ describe BinData::String, "with :length" do
   its(:num_bytes) { should == 5 }
   its(:value) { should == "\0\0\0\0\0" }
 
-  it "should retain :length after value is set" do
+  it "retains :length after value is set" do
     subject.assign("abcdefghij")
     subject.num_bytes.should == 5
   end
 
-  it "should read :length bytes" do
+  it "reads :length bytes" do
     subject.read("abcdefghij")
     subject.should == "abcde"
   end
 
-  it "should pad values less than :length" do
+  it "pads values less than :length" do
     subject.assign("abc")
     subject.should == "abc\0\0"
   end
 
-  it "should accept values exactly :length" do
+  it "accepts values exactly :length" do
     subject.assign("abcde")
     subject.should == "abcde"
   end
 
-  it "should truncate values greater than :length" do
+  it "truncates values greater than :length" do
     subject.assign("abcdefghij")
     subject.should == "abcde"
   end
@@ -107,13 +107,13 @@ describe BinData::String, "with :read_length and :initial_value" do
   its(:num_bytes) { should == 10 }
   its(:value) { should == "abcdefghij" }
 
-  it "should use :read_length for reading" do
+  it "uses :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     subject.read(io)
     io.pos.should == 5
    end
 
-  it "should forget :initial_value after reading" do
+  it "forgets :initial_value after reading" do
     subject.read("ABCDEFGHIJKLMNOPQRST")
     subject.num_bytes.should == 5
     subject.should == "ABCDE"
@@ -126,7 +126,7 @@ describe BinData::String, "with :read_length and :value" do
   its(:num_bytes) { should == 10 }
   its(:value) { should == "abcdefghij" }
 
-  it "should use :read_length for reading" do
+  it "uses :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     subject.read(io)
     io.pos.should == 5
@@ -137,12 +137,12 @@ describe BinData::String, "with :read_length and :value" do
       subject.read("ABCDEFGHIJKLMNOPQRST")
     end
 
-    it "should not be affected by :read_length after reading" do
+    it "is not affected by :read_length after reading" do
       subject.num_bytes.should == 10
       subject.should == "abcdefghij"
     end
 
-    it "should return read value while reading" do
+    it "returns read value while reading" do
       subject.stub(:reading?).and_return(true)
       subject.should == "ABCDE"
     end
@@ -155,7 +155,7 @@ describe BinData::String, "with :length and :initial_value" do
   its(:num_bytes) { should == 5 }
   its(:value) { should == "abcde" }
 
-  it "should forget :initial_value after reading" do
+  it "forgets :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     subject.read(io)
     io.pos.should == 5
@@ -164,21 +164,21 @@ describe BinData::String, "with :length and :initial_value" do
   end
 end
 
-describe BinData::String, "with :pad_char" do
-  it "should accept a numeric value for :pad_char" do
-    str = BinData::String.new(:length => 5, :pad_char => 6)
+describe BinData::String, "with :pad_byte" do
+  it "accepts a numeric value for :pad_byte" do
+    str = BinData::String.new(:length => 5, :pad_byte => 6)
     str.assign("abc")
     str.should == "abc\x06\x06"
   end
 
-  it "should accept a character for :pad_char" do
-    str = BinData::String.new(:length => 5, :pad_char => "R")
+  it "accepts a character for :pad_byte" do
+    str = BinData::String.new(:length => 5, :pad_byte => "R")
     str.assign("abc")
     str.should == "abcRR"
   end
 
-  it "should not accept a string for :pad_char" do
-    params = {:length => 5, :pad_char => "RR"}
+  it "does not accept a string for :pad_byte" do
+    params = {:length => 5, :pad_byte => "RR"}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
   end
 end
@@ -194,24 +194,24 @@ describe BinData::String, "with :trim_padding" do
   end
 
   context "trim padding set" do
-    subject { BinData::String.new(:pad_char => 'R', :trim_padding => true) }
+    subject { BinData::String.new(:pad_byte => 'R', :trim_padding => true) }
 
-    it "should trim the value" do
+    it "trims the value" do
       subject.assign("abcRR")
       subject.should == "abc"
     end
 
-    it "should not affect num_bytes" do
+    it "does not affect num_bytes" do
       subject.assign("abcRR")
       subject.num_bytes.should == 5
     end
 
-    it "should trim if last char is :pad_char" do
+    it "trims if last char is :pad_byte" do
       subject.assign("abcRR")
       subject.should == "abc"
     end
 
-    it "should not trim if value contains :pad_char not at the end" do
+    it "does not trim if value contains :pad_byte not at the end" do
       subject.assign("abcRRde")
       subject.should == "abcRRde"
     end
@@ -230,25 +230,25 @@ describe BinData::String, "with Ruby 1.9 encodings" do
     let(:binary_str) { "\xC3\x85\xC3\x84\xC3\x96" }
     let(:utf8_str) { binary_str.dup.force_encoding('UTF-8') }
 
-    it "should store assigned values as binary" do
+    it "stores assigned values as binary" do
       subject.assign(utf8_str)
       subject.to_binary_s.should == binary_str
     end
 
-    it "should store read values as binary" do
+    it "stores read values as binary" do
       subject = UTF8String.new(:read_length => binary_str.length)
       subject.read(binary_str)
 
       subject.to_binary_s.should == binary_str
     end
 
-    it "should return values in correct encoding" do
+    it "returns values in correct encoding" do
       subject.assign(utf8_str)
 
       subject.snapshot.should == utf8_str
     end
 
-    it "should have correct num_bytes" do
+    it "has correct num_bytes" do
       subject.assign(utf8_str)
 
       subject.num_bytes.should == binary_str.length

data/spec/stringz_spec.rb

@@ -18,47 +18,47 @@ describe BinData::Stringz, "with value set" do
 end
 
 describe BinData::Stringz, "when reading" do
-  it "should stop at the first zero byte" do
+  it "stops at the first zero byte" do
     io = StringIO.new("abcd\0xyz\0")
     subject.read(io)
     io.pos.should == 5
     subject.should == "abcd"
   end
 
-  it "should handle a zero length string" do
+  it "handles a zero length string" do
     io = StringIO.new("\0abcd")
     subject.read(io)
     io.pos.should == 1
     subject.should == ""
   end
 
-  it "should fail if no zero byte is found" do
-    lambda {subject.read("abcd") }.should raise_error(EOFError)
+  it "fails if no zero byte is found" do
+    expect {subject.read("abcd") }.to raise_error(EOFError)
   end
 end
 
 describe BinData::Stringz, "when setting the value" do
-  it "should include the zero byte in num_bytes total" do
+  it "includes the zero byte in num_bytes total" do
     subject.assign("abcd")
     subject.num_bytes.should == 5
   end
 
-  it "should accept empty strings" do
+  it "accepts empty strings" do
     subject.assign("")
     subject.should == ""
   end
 
-  it "should accept strings that aren't zero terminated" do
+  it "accepts strings that aren't zero terminated" do
     subject.assign("abcd")
     subject.should == "abcd"
   end
 
-  it "should accept strings that are zero terminated" do
+  it "accepts strings that are zero terminated" do
     subject.assign("abcd\0")
     subject.should == "abcd"
   end
 
-  it "should accept up to the first zero byte" do
+  it "accepts up to the first zero byte" do
     subject.assign("abcd\0xyz\0")
     subject.should == "abcd"
   end
@@ -67,51 +67,51 @@ end
 describe BinData::Stringz, "with max_length" do
   subject { BinData::Stringz.new(:max_length => 5) }
 
-  it "should read less than max_length" do
+  it "reads less than max_length" do
     io = StringIO.new("abc\0xyz")
     subject.read(io)
     subject.should == "abc"
   end
 
-  it "should read exactly max_length" do
+  it "reads exactly max_length" do
     io = StringIO.new("abcd\0xyz")
     subject.read(io)
     subject.should == "abcd"
   end
 
-  it "should read no more than max_length" do
+  it "reads no more than max_length" do
     io = StringIO.new("abcdefg\0xyz")
     subject.read(io)
     io.pos.should == 5
     subject.should == "abcd"
   end
 
-  it "should accept values less than max_length" do
+  it "accepts values less than max_length" do
     subject.assign("abc")
     subject.should == "abc"
   end
 
-  it "should accept values exactly max_length" do
+  it "accepts values exactly max_length" do
     subject.assign("abcd")
     subject.should == "abcd"
   end
 
-  it "should trim values greater than max_length" do
+  it "trims values greater than max_length" do
     subject.assign("abcde")
     subject.should == "abcd"
   end
 
-  it "should write values greater than max_length" do
+  it "writes values greater than max_length" do
     subject.assign("abcde")
     subject.to_binary_s.should == "abcd\0"
   end
 
-  it "should write values less than max_length" do
+  it "writes values less than max_length" do
     subject.assign("abc")
     subject.to_binary_s.should == "abc\0"
   end
 
-  it "should write values exactly max_length" do
+  it "writes values exactly max_length" do
     subject.assign("abcd")
     subject.to_binary_s.should == "abcd\0"
   end