bindata 1.2.2 → 1.3.1

data/spec/registry_spec.rb

@@ -12,102 +12,98 @@ describe BinData::Registry do
   C = Class.new
   D = Class.new
 
-  before(:each) do
-    @r = BinData::Registry.new
-  end
+  let(:r) { BinData::Registry.new }
 
   it "should determine if a name is registered" do
-    @r.register('A', A)
+    r.register('A', A)
 
-    @r.is_registered?('a').should be_true
+    r.is_registered?('a').should be_true
   end
 
   it "should determine if a name is not registered" do
     lambda {
-      @r.is_registered?('xyz')
+      r.is_registered?('xyz')
     }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should lookup registered names" do
-    @r.register('ASubClass', A)
-    @r.register('AnotherSubClass', B)
+    r.register('ASubClass', A)
+    r.register('AnotherSubClass', B)
 
-    @r.lookup('a_sub_class').should == A
-    @r.lookup('another_sub_class').should  == B
+    r.lookup('a_sub_class').should == A
+    r.lookup('another_sub_class').should  == B
   end
 
   it "should not lookup unregistered names" do
     lambda {
-      @r.lookup('a_non_existent_sub_class')
+      r.lookup('a_non_existent_sub_class')
     }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should allow overriding of registered classes" do
-    @r.register('A', A)
-    @r.register('A', B)
+    r.register('A', A)
+    r.register('A', B)
 
-    @r.lookup('a').should == B
+    r.lookup('a').should == B
   end
 
   it "should convert CamelCase to underscores" do
-    @r.underscore_name('CamelCase').should == 'camel_case'
+    r.underscore_name('CamelCase').should == 'camel_case'
   end
 
   it "should convert adjacent caps camelCase to underscores" do
-    @r.underscore_name('XYZCamelCase').should == 'xyz_camel_case'
+    r.underscore_name('XYZCamelCase').should == 'xyz_camel_case'
   end
 
   it "should ignore the outer nestings of classes" do
-    @r.underscore_name('A::B::C').should == 'c'
+    r.underscore_name('A::B::C').should == 'c'
   end
 end
 
 describe BinData::Registry, "with numerics" do
-  before(:each) do
-    @r = BinData::RegisteredClasses
-  end
+  let(:r) { BinData::RegisteredClasses }
 
   it "should 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"
+    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 {
-      @r.lookup("int24")
+      r.lookup("int24")
     }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should not lookup non byte based integers" do
     lambda {
-      @r.lookup("int3")
+      r.lookup("int3")
     }.should raise_error(BinData::UnRegisteredTypeError)
     lambda {
-      @r.lookup("int3", :big)
+      r.lookup("int3", :big)
     }.should raise_error(BinData::UnRegisteredTypeError)
     lambda {
-      @r.lookup("int3", :little)
+      r.lookup("int3", :little)
     }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should 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"
+    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
-    @r.lookup("bit5").to_s.should == "BinData::Bit5"
-    @r.lookup("bit6le").to_s.should == "BinData::Bit6le"
+    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
-    @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"
-    @r.lookup("bit3le", :little).to_s.should == "BinData::Bit3le"
+    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"
+    r.lookup("bit3le", :little).to_s.should == "BinData::Bit3le"
   end
 end

data/spec/rest_spec.rb

@@ -4,26 +4,23 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/rest'
 
 describe BinData::Rest do
+  it { should == "" }
+
   it "should read till end of stream" do
     data = "abcdefghij"
-    BinData::Rest.read(data).should == data
-  end
-
-  it "should default to the empty string" do
-    BinData::Rest.new.value.should == ""
+    subject.read(data).should == data
   end
 
   it "should allow setting value for completeness" do
-    rest = BinData::Rest.new
-    rest.value = "123"
-    rest.value.should == "123"
-    rest.to_binary_s.should == "123"
+    subject.assign("123")
+    subject.should == "123"
+    subject.to_binary_s.should == "123"
   end
 
   it "should accept BinData::BasePrimitive parameters" do
     rest = BinData::Rest.new(:check_value => "abc")
     lambda {
-      rest.read("abc")
-    }.should_not raise_error(BinData::ValidityError)
+      rest.read("xyz")
+    }.should raise_error(BinData::ValidityError)
   end
 end

data/spec/skip_spec.rb

@@ -4,32 +4,24 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/skip'
 
 describe BinData::Skip do
-  before(:each) do
-    @skip = BinData::Skip.new(:length => 5)
-  end
+  subject { BinData::Skip.new(:length => 5) }
+  let(:io) { StringIO.new("abcdefghij") }
 
-  it "should default to the empty string" do
-    @skip.should == ""
-  end
+  it { should == "" }
+  its(:to_binary_s) { should == "\000" * 5 }
 
   it "should skip bytes" do
-    io = StringIO.new("abcdefghij")
-    @skip.read(io)
+    subject.read(io)
     io.pos.should == 5
   end
 
-  it "should have expected binary representation" do
-    @skip.to_binary_s.should == "\000" * 5
-  end
-
   it "should have expected binary representation after setting value" do
-    @skip.value = "123"
-    @skip.to_binary_s.should == "\000" * 5
+    subject.assign("123")
+    subject.to_binary_s.should == "\000" * 5
   end
 
   it "should have expected binary representation after reading" do
-    io = StringIO.new("abcdefghij")
-    @skip.read(io)
-    @skip.to_binary_s.should == "\000" * 5
+    subject.read(io)
+    subject.to_binary_s.should == "\000" * 5
   end
 end

data/spec/spec_common.rb

@@ -13,6 +13,10 @@ class Object
     protected_method_names = cls.protected_instance_methods - Object.protected_instance_methods
     cls.send(:public, *protected_method_names)
   end
+
+  def value_read_from_written
+    self.class.read(self.to_binary_s)
+  end
 end
 
 class StringIO

data/spec/string_spec.rb

@@ -22,170 +22,147 @@ describe BinData::String, "with mutually exclusive parameters" do
 end
 
 describe BinData::String, "when assigning" do
-  before(:each) do
-    @small = BinData::String.new(:length => 3, :pad_char => "A")
-    @large = BinData::String.new(:length => 5, :pad_char => "B")
-  end
+  let(:small) { BinData::String.new(:length => 3, :pad_char => "A") }
+  let(:large) { BinData::String.new(:length => 5, :pad_char => "B") }
 
   it "should copy data from small to large" do
-    @large.value = @small
-    @large.value.should == "AAABB"
+    large.assign(small)
+    large.should == "AAABB"
   end
 
   it "should copy data from large to small" do
-    @small.value = @large
-    @small.value.should == "BBB"
+    small.assign(large)
+    small.should == "BBB"
   end
 end
 
 describe BinData::String, "with :read_length" do
-  before(:each) do
-    @str = BinData::String.new(:read_length => 5)
-  end
+  subject { BinData::String.new(:read_length => 5) }
 
-  it "should have default value" do
-    @str.num_bytes.should == 0
-    @str.value.should == ""
-  end
+  its(:num_bytes) { should == 0 }
+  its(:value) { should == "" }
 
   it "should read :read_length bytes" do
-    @str.read("abcdefghij")
-    @str.value.should == "abcde"
+    subject.read("abcdefghij")
+    subject.should == "abcde"
   end
 
   it "should remember :read_length after value is cleared" do
-    @str.value = "abc"
-    @str.num_bytes.should == 3
-    @str.clear
+    subject.assign("abc")
+    subject.num_bytes.should == 3
+    subject.clear
 
-    @str.read("abcdefghij")
-    @str.value.should == "abcde"
+    subject.read("abcdefghij")
+    subject.should == "abcde"
   end
 end
 
 describe BinData::String, "with :length" do
-  before(:each) do
-    @str = BinData::String.new(:length => 5)
-  end
-
-  it "should set num_bytes" do
-    @str.num_bytes.should == 5
-  end
+  subject { BinData::String.new(:length => 5) }
 
-  it "should fill value with pad_char" do
-    @str.value.should == "\0\0\0\0\0"
-  end
+  its(:num_bytes) { should == 5 }
+  its(:value) { should == "\0\0\0\0\0" }
 
   it "should retain :length after value is set" do
-    @str.value = "abcdefghij"
-    @str.num_bytes.should == 5
+    subject.assign("abcdefghij")
+    subject.num_bytes.should == 5
   end
 
   it "should read :length bytes" do
-    @str.read("abcdefghij")
-    @str.value.should == "abcde"
+    subject.read("abcdefghij")
+    subject.should == "abcde"
   end
 
   it "should pad values less than :length" do
-    @str.value = "abc"
-    @str.value.should == "abc\0\0"
+    subject.assign("abc")
+    subject.should == "abc\0\0"
   end
 
   it "should accept values exactly :length" do
-    @str.value = "abcde"
-    @str.value.should == "abcde"
+    subject.assign("abcde")
+    subject.should == "abcde"
   end
 
   it "should truncate values greater than :length" do
-    @str.value = "abcdefg"
-    @str.value.should == "abcde"
+    subject.assign("abcdefghij")
+    subject.should == "abcde"
   end
 end
 
 describe BinData::String, "with :read_length and :initial_value" do
-  before(:each) do
-    @str = BinData::String.new(:read_length => 5, :initial_value => "abcdefghij")
-  end
+  subject { BinData::String.new(:read_length => 5, :initial_value => "abcdefghij") }
 
-  it "should use :initial_value before value is read" do
-    @str.num_bytes.should == 10
-    @str.value.should == "abcdefghij"
-  end
+  its(:num_bytes) { should == 10 }
+  its(:value) { should == "abcdefghij" }
 
   it "should use :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-    @str.read(io)
+    subject.read(io)
     io.pos.should == 5
    end
 
   it "should forget :initial_value after reading" do
-    @str.read("ABCDEFGHIJKLMNOPQRST")
-    @str.num_bytes.should == 5
-    @str.value.should == "ABCDE"
+    subject.read("ABCDEFGHIJKLMNOPQRST")
+    subject.num_bytes.should == 5
+    subject.should == "ABCDE"
   end
 end
 
 describe BinData::String, "with :read_length and :value" do
-  before(:each) do
-    @str = BinData::String.new(:read_length => 5, :value => "abcdefghij")
-  end
+  subject { BinData::String.new(:read_length => 5, :value => "abcdefghij") }
 
-  it "should not be affected by :read_length before value is read" do
-    @str.num_bytes.should == 10
-    @str.value.should == "abcdefghij"
-  end
+  its(:num_bytes) { should == 10 }
+  its(:value) { should == "abcdefghij" }
 
   it "should use :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-    @str.read(io)
+    subject.read(io)
     io.pos.should == 5
-   end
-
-  it "should not be affected by :read_length after reading" do
-    @str.read("ABCDEFGHIJKLMNOPQRST")
-    @str.num_bytes.should == 10
-    @str.value.should == "abcdefghij"
   end
 
-  it "should return read value while reading" do
-    @str.read("ABCDEFGHIJKLMNOPQRST")
+  context "after reading" do
+    before(:each) do
+      subject.read("ABCDEFGHIJKLMNOPQRST")
+    end
 
-    def @str.reading?; true; end
+    it "should not be affected by :read_length after reading" do
+      subject.num_bytes.should == 10
+      subject.should == "abcdefghij"
+    end
 
-    @str.value.should == "ABCDE"
+    it "should return read value while reading" do
+      subject.stub(:reading?).and_return(true)
+      subject.should == "ABCDE"
+    end
   end
 end
 
 describe BinData::String, "with :length and :initial_value" do
-  before(:each) do
-    @str = BinData::String.new(:length => 5, :initial_value => "abcdefghij")
-  end
+  subject { BinData::String.new(:length => 5, :initial_value => "abcdefghij") }
 
-  it "should apply :length to :initial_value" do
-    @str.num_bytes.should == 5
-    @str.value.should == "abcde"
-  end
+  its(:num_bytes) { should == 5 }
+  its(:value) { should == "abcde" }
 
   it "should forget :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-    @str.read(io)
+    subject.read(io)
     io.pos.should == 5
-    @str.num_bytes.should == 5
-    @str.value.should == "ABCDE"
+    subject.num_bytes.should == 5
+    subject.should == "ABCDE"
   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)
-    @str.value = "abc"
-    @str.value.should == "abc\x06\x06"
+    str = BinData::String.new(:length => 5, :pad_char => 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")
-    @str.value = "abc"
-    @str.value.should == "abcRR"
+    str = BinData::String.new(:length => 5, :pad_char => "R")
+    str.assign("abc")
+    str.should == "abcRR"
   end
 
   it "should not accept a string for :pad_char" do
@@ -198,33 +175,33 @@ describe BinData::String, "with :trim_padding" do
   it "set false is the default" do
     str1 = BinData::String.new(:length => 5)
     str2 = BinData::String.new(:length => 5, :trim_padding => false)
-    str1.value = "abc"
-    str2.value = "abc"
-    str1.value.should == "abc\0\0"
-    str2.value.should == "abc\0\0"
-  end
-
-  it "should trim the value" do
-    str = BinData::String.new(:pad_char => 'R', :trim_padding => true)
-    str.value = "abcRR"
-    str.value.should == "abc"
-  end
-
-  it "should not affect num_bytes" do
-    str = BinData::String.new(:pad_char => 'R', :trim_padding => true)
-    str.value = "abcRR"
-    str.num_bytes.should == 5
-  end
-
-  it "should trim if last char is :pad_char" do
-    str = BinData::String.new(:pad_char => 'R', :trim_padding => true)
-    str.value = "abcRR"
-    str.value.should == "abc"
-  end
-
-  it "should not trim if value contains :pad_char not at the end" do
-    str = BinData::String.new(:pad_char => 'R', :trim_padding => true)
-    str.value = "abcRRde"
-    str.value.should == "abcRRde"
+    str1.assign("abc")
+    str2.assign("abc")
+    str1.should == "abc\0\0"
+    str2.should == "abc\0\0"
+  end
+
+  context "trim padding set" do
+    subject { BinData::String.new(:pad_char => 'R', :trim_padding => true) }
+
+    it "should trim the value" do
+      subject.assign("abcRR")
+      subject.should == "abc"
+    end
+
+    it "should not affect num_bytes" do
+      subject.assign("abcRR")
+      subject.num_bytes.should == 5
+    end
+
+    it "should trim if last char is :pad_char" do
+      subject.assign("abcRR")
+      subject.should == "abc"
+    end
+
+    it "should not trim if value contains :pad_char not at the end" do
+      subject.assign("abcRRde")
+      subject.should == "abcRRde"
+    end
   end
 end