bindata 0.8.1 → 0.9.0

data/spec/registry_spec.rb

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

data/spec/rest_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/rest'
+
+describe BinData::Rest do
+  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 == ""
+  end
+
+  it "should allow setting value for completeness" do
+    rest = BinData::Rest.new
+    rest.value = "123"
+    rest.value.should == "123"
+    rest.to_s.should == "123"
+  end
+
+  it "should accept BinData::Single parameters" do
+    rest = BinData::Rest.new(:check_value => "abc")
+    lambda {
+      rest.read("abc")
+    }.should_not raise_error(BinData::ValidityError)
+  end
+end
+

data/spec/sanitize_spec.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata/sanitize'
+
+describe BinData::SanitizedParameters, "with nil parameters" do
+  before(:each) do
+    @mock = mock("dummy class")
+    @mock.stub!(:accepted_parameters).and_return([:a, :b, :c])
+  end
+
+  it "should return empty parameters" do
+    @mock.should_receive(:sanitize_parameters).with({}).and_return({})
+
+    sanitized = BinData::SanitizedParameters.new(@mock, nil)
+    sanitized.keys.should be_empty
+  end
+
+  it "should pass extra arguments" do
+    @mock.should_receive(:sanitize_parameters).with({}, 1, 2, 3).and_return({})
+
+    sanitized = BinData::SanitizedParameters.new(@mock, nil, 1, 2, 3)
+    sanitized.keys.should be_empty
+  end
+end
+
+describe BinData::SanitizedParameters, "with bad input" do
+  before(:each) do
+    @mock = mock("dummy class")
+    @mock.stub!(:accepted_parameters).and_return([:a, :b, :c])
+    @params = {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+  end
+
+  it "should convert keys to symbols" do
+    the_params = {'a' => 1, 'b' => 2, 'e' => 5}
+    @mock.should_receive(:sanitize_parameters).with(the_params).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, the_params)
+    sanitized.accepted_parameters.should == ({:a => 1, :b => 2})
+    sanitized.extra_parameters.should == ({:e => 5})
+  end
+
+  it "should raise error if parameter has nil value" do
+    the_params = {'a' => 1, 'b' => nil, 'e' => 5}
+    @mock.should_receive(:sanitize_parameters).with(the_params).
+      and_return { |params, *rest| params }
+
+    lambda {
+      BinData::SanitizedParameters.new(@mock, the_params)
+    }.should raise_error(ArgumentError)
+  end
+end
+
+describe BinData::SanitizedParameters do
+  before(:each) do
+    @mock = mock("dummy class")
+    @mock.stub!(:accepted_parameters).and_return([:a, :b, :c])
+    @params = {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+  end
+
+  it "should pass extra arguments" do
+    @mock.should_receive(:sanitize_parameters).with(@params, 1, 2, 3).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, @params, 1, 2, 3)
+  end
+
+  it "should partition" do
+    @mock.should_receive(:sanitize_parameters).with(@params).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, @params)
+    sanitized.accepted_parameters.should == ({:a => 1, :b => 2, :c => 3})
+    sanitized.extra_parameters.should == ({:d => 4, :e => 5})
+  end
+
+  it "should respond_to keys" do
+    @mock.should_receive(:sanitize_parameters).with(@params).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, @params)
+    sanitized.should respond_to(:keys)
+    keys = sanitized.keys.collect { |x| x.to_s }
+    keys.sort.should ==(['a', 'b', 'c', 'd', 'e'])
+  end
+
+  it "should respond_to has_key?" do
+    @mock.should_receive(:sanitize_parameters).with(@params).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, @params)
+    sanitized.should respond_to(:has_key?)
+    sanitized.has_key?(:a).should be_true
+    sanitized.has_key?(:e).should be_true
+    sanitized.has_key?(:z).should be_false
+  end
+
+  it "should respond_to []" do
+    @mock.should_receive(:sanitize_parameters).with(@params).
+      and_return { |params, *rest| params }
+
+    sanitized = BinData::SanitizedParameters.new(@mock, @params)
+    sanitized.should respond_to(:[])
+    sanitized[:a].should == 1
+    sanitized[:d].should == 4
+  end
+end

data/spec/single_spec.rb

@@ -12,37 +12,11 @@ class ConcreteSingle < BinData::Single
   def in_read?()         @in_read end
 end
 
-describe "The sample implementation of Single" do
-  it "should have symmetric IO" do
-    io = StringIO.new
-    data = ConcreteSingle.new
-    data.value = 42
-    data.write(io)
-
-    io.rewind
-    data = ConcreteSingle.new
-    data.read(io)
-    data.value.should eql(42)
-  end
-end
-
-describe "The class Single" do
-  it "should register subclasses" do
-    BinData::Single.lookup(:concrete_single).should eql(ConcreteSingle)
-  end
-
-  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
-
-describe "A Single object" do
+describe BinData::Single 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)
+    data.value.should == 5
   end
 
   it "should conform to rule 2 for returning a value" do
@@ -50,37 +24,37 @@ describe "A Single object" do
     data = ConcreteSingle.new(:value => 5)
     data.do_read(io)
     data.should be_in_read
-    data.value.should eql(42)
+    data.value.should == 42
   end
 
   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)
+    data.value.should == 5
   end
 
   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)
+    data.value.should == 17
   end
 
   it "should conform to rule 5 for returning a value" do
     data = ConcreteSingle.new
     data.should be_clear
-    data.value.should eql(0)
+    data.value.should == 0
   end
 
   it "should conform to rule 6 for returning a value" do
     data = ConcreteSingle.new
     data.value = 8
     data.should_not be_clear
-    data.value.should eql(8)
+    data.value.should == 8
   end
 end
 
-describe "A new Single object" do
+describe BinData::Single, "after initialisation" do
   before(:each) do
     @data = ConcreteSingle.new
   end
@@ -90,13 +64,32 @@ describe "A new Single object" do
     lambda { ConcreteSingle.new(params) }.should raise_error(ArgumentError)
   end
 
+  it "should not have any field_names" do
+    BinData::Single.all_possible_field_names(nil).should be_empty
+  end
+
   it "should have a sensible value" do
-    @data.value.should eql(0)
+    @data.value.should == 0
+  end
+
+  it "should have symmetric IO" do
+    io = StringIO.new
+    @data.value = 42
+    @data.write(io)
+
+    io.rewind
+    @data = ConcreteSingle.new
+    @data.read(io)
+    @data.value.should == 42
+  end
+
+  it "should be a single_value" do
+    @data.should be_single_value
   end
 
   it "should allowing setting and retrieving value" do
     @data.value = 5
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 
   it "should be clear" do
@@ -115,7 +108,7 @@ describe "A new Single object" do
   end
 
   it "should return num_bytes" do
-    @data.num_bytes.should eql(4)
+    @data.num_bytes.should == 4
   end
 
   it "should not contain any field names" do
@@ -124,66 +117,66 @@ describe "A new Single object" do
 
   it "should return a snapshot" do
     @data.value = 5
-    @data.snapshot.should eql(5)
+    @data.snapshot.should == 5
   end
 end
 
-describe "A Single with :initial_value" do
+describe BinData::Single, "with :initial_value" do
   before(:each) do
     @data = ConcreteSingle.new(:initial_value => 5)
   end
 
   it "should return that initial value before reading or being set" do
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 
   it "should forget :initial_value after being set" do
     @data.value = 17
-    @data.value.should_not eql(5)
+    @data.value.should_not == 5
   end
 
   it "should forget :initial_value after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
-    @data.value.should_not eql(5)
+    @data.value.should_not == 5
   end
 
   it "should remember :initial_value after being cleared" do
     @data.value = 17
     @data.clear
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 end
 
-describe "A Single with :value" do
+describe BinData::Single, "with :value" do
   before(:each) do
     @data = ConcreteSingle.new(:value => 5)
   end
 
   it "should return that :value" do
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 
   it "should change during reading" do
     io = StringIO.new([56].pack("V"))
     @data.do_read(io)
-    @data.value.should eql(56)
+    @data.value.should == 56
     @data.done_read
   end
 
   it "should not change after reading" do
     io = StringIO.new([56].pack("V"))
     @data.read(io)
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 
   it "should not be able to change the value" do
     @data.value = 17
-    @data.value.should eql(5)
+    @data.value.should == 5
   end
 end
 
-describe "A Single with :check_value" do
+describe BinData::Single, "with :check_value" do
   before(:each) do
     @io = StringIO.new([34].pack("V"))
   end
@@ -208,3 +201,24 @@ describe "A Single with :check_value" do
     lambda { data.read(@io) }.should raise_error(BinData::ValidityError)
   end
 end
+
+describe BinData::Single, "when subclassing" do
+  before(:all) do
+    eval <<-END
+      class SubClassOfSingle < BinData::Single
+        public :val_to_str, :read_val, :sensible_default
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = SubClassOfSingle.new
+  end
+
+  it "should raise errors on unimplemented methods" do
+    lambda { @obj.val_to_str(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj.read_val(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj.sensible_default }.should raise_error(NotImplementedError)
+  end
+end
+

data/spec/single_value_spec.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require 'bindata'
+
+describe BinData::SingleValue do
+  before(:all) do
+    eval <<-END
+      class SingleValueWithEndian < BinData::SingleValue
+        endian :little
+        int16 :a
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = SingleValueWithEndian.new
+  end
+
+  it "should support endian" do
+    @obj.value = 5
+    @obj.to_s.should == "\x05\x00"
+  end
+
+  it "should set value" do
+    @obj.value = 5
+    @obj.to_s.should == "\x05\x00"
+  end
+
+  it "should read value" do
+    @obj.read("\x00\x01")
+    @obj.value.should == 0x100
+  end
+
+  it "should accept standard parameters" do
+    obj = SingleValueWithEndian.new(:initial_value => 2)
+    obj.to_s.should == "\x02\x00"
+  end
+
+  it "should return num_bytes" do
+    @obj.num_bytes.should == 2
+  end
+
+  it "should raise error on missing methods" do
+    lambda {
+      @obj.does_not_exist
+    }.should raise_error(NoMethodError)
+  end
+end
+
+describe BinData::SingleValue, "requiring extra parameters" do
+  before(:all) do
+    eval <<-END
+      class SingleValueWithExtra < BinData::SingleValue
+        int8 :a, :initial_value => :iv
+        def get; self.a; end
+        def set(v); self.a = v; end
+      end
+    END
+  end
+
+  it "should pass parameters correctly" do
+    obj = SingleValueWithExtra.new(:iv => 5)
+    obj.value.should == 5
+  end
+end
+
+describe BinData::SingleValue, "when subclassing" do
+  before(:all) do
+    eval <<-END
+      class SubClassOfSingleValue < BinData::SingleValue
+        public :get, :set
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = SubClassOfSingleValue.new
+  end
+
+  it "should raise errors on unimplemented methods" do
+    lambda { @obj.set(nil) }.should raise_error(NotImplementedError)
+    lambda { @obj.get }.should raise_error(NotImplementedError)
+  end
+end
+
+describe BinData::SingleValue, "when defining" do
+  it "should fail on non registered types" do
+    lambda {
+      eval <<-END
+        class BadTypeSingleValue < BinData::SingleValue
+          non_registerd_type :a
+        end
+      END
+    }.should raise_error(TypeError)
+  end
+
+  it "should fail on duplicate names" do
+    lambda {
+      eval <<-END
+        class DuplicateNameSingleValue < BinData::SingleValue
+          int8 :a
+          int8 :b
+          int8 :a
+        end
+      END
+    }.should raise_error(SyntaxError)
+  end
+
+  it "should fail when field name shadows an existing method" do
+    lambda {
+      eval <<-END
+        class ExistingNameSingleValue < BinData::SingleValue
+          int8 :object_id
+        end
+      END
+    }.should raise_error(NameError)
+  end
+
+  it "should fail on unknown endian" do
+    lambda {
+      eval <<-END
+        class BadEndianSingleValue < BinData::SingleValue
+          endian 'a bad value'
+        end
+      END
+    }.should raise_error(ArgumentError)
+  end
+end