bindata 1.5.1 → 1.6.0

data/{spec/lazy_spec.rb → test/lazy_test.rb}

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata/lazy'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
 # A mock data object with customizable fields.
 class MockBinDataObject
@@ -42,33 +41,33 @@ describe BinData::LazyEvaluator, "with no parents" do
   }
 
   it "evaluates raw value when instantiated" do
-    lazy_eval(5).should == 5
+    lazy_eval(5).must_equal 5
   end
 
   it "evaluates raw value" do
-    lazy_eval(5).should == 5
+    lazy_eval(5).must_equal 5
   end
 
   it "evaluates value" do
-    lazy_eval(lambda { 5 }).should == 5
+    lazy_eval(lambda { 5 }).must_equal 5
   end
 
   it "evaluates overrides" do
-    lazy_eval(lambda { o1 }, :o1 => 'o1').should == 'o1'
+    lazy_eval(lambda { o1 }, :o1 => 'o1').must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
-    expect { lazy_eval(lambda { unknown }) }.to raise_error(NameError)
-    expect { lazy_eval(lambda { m1 }) }.to raise_error(NameError)
-    expect { lazy_eval(lambda { p1 }) }.to raise_error(NameError)
+    lambda { lazy_eval(lambda { unknown }) }.must_raise NameError
+    lambda { lazy_eval(lambda { m1 }) }.must_raise NameError
+    lambda { lazy_eval(lambda { p1 }) }.must_raise NameError
   end
 
   it "does not have a parent" do
-    lazy_eval(lambda { parent }).should be_nil
+    lazy_eval(lambda { parent }).must_be_nil
   end
 
   it "does not resolve #index" do
-    expect { lazy_eval(lambda { index }) }.to raise_error(NoMethodError)
+    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end
 
@@ -88,47 +87,47 @@ describe BinData::LazyEvaluator, "with one parent" do
   }
 
   it "evaluates raw value" do
-    lazy_eval(5).should == 5
+    lazy_eval(5).must_equal 5
   end
 
   it "evaluates value" do
-    lazy_eval(lambda { 5 }).should == 5
+    lazy_eval(lambda { 5 }).must_equal 5
   end
 
   it "evaluates overrides before params" do
-    lazy_eval(lambda { p1 }, :p1 => 'o1').should == 'o1'
+    lazy_eval(lambda { p1 }, :p1 => 'o1').must_equal 'o1'
   end
 
   it "evaluates overrides before methods" do
-    lazy_eval(lambda { m1 }, :m1 => 'o1').should == 'o1'
+    lazy_eval(lambda { m1 }, :m1 => 'o1').must_equal 'o1'
   end
 
   it "does not resolve any unknown methods" do
-    expect { lazy_eval(lambda { unknown }) }.to raise_error(NameError)
+    lambda { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
   end
 
   it "resolves parameters in the parent" do
-    lazy_eval(lambda { p1 }).should == 'Pp1'
+    lazy_eval(lambda { p1 }).must_equal 'Pp1'
   end
 
   it "resolves methods in the parent" do
-    lazy_eval(lambda { m1 }).should == 'Pm1'
+    lazy_eval(lambda { m1 }).must_equal 'Pm1'
   end
 
   it "invokes methods in the parent" do
-    lazy_eval(lambda { echo(p1, m1) }).should == ['Pp1', 'Pm1']
+    lazy_eval(lambda { echo(p1, m1) }).must_equal ['Pp1', 'Pm1']
   end
 
   it "resolves parameters in preference to methods in the parent" do
-    lazy_eval(lambda { com }).should == 'PpC'
+    lazy_eval(lambda { com }).must_equal 'PpC'
   end
 
   it "has a parent" do
-    lazy_eval(lambda { parent }).should_not be_nil
+    lazy_eval(lambda { parent }).wont_be_nil
   end
 
   it "does not resolve #index" do
-    expect { lazy_eval(lambda { index }) }.to raise_error(NoMethodError)
+    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end
 
@@ -160,58 +159,58 @@ describe BinData::LazyEvaluator, "with nested parents" do
   }
 
   it "accepts symbols as a shortcut to lambdas" do
-    lazy_eval(:p1).should == 'Pp1'
-    lazy_eval(:p2).should == 'PPp2'
-    lazy_eval(:m1).should == 'Pm1'
-    lazy_eval(:m2).should == 'PPm2'
+    lazy_eval(:p1).must_equal 'Pp1'
+    lazy_eval(:p2).must_equal 'PPp2'
+    lazy_eval(:m1).must_equal 'Pm1'
+    lazy_eval(:m2).must_equal 'PPm2'
   end
 
   it "does not resolve any unknown methods" do
-    expect { lazy_eval(lambda { unknown }) }.to raise_error(NameError)
+    lambda { lazy_eval(lambda { unknown }) }.must_raise NoMethodError
   end
 
   it "resolves parameters in the parent" do
-    lazy_eval(lambda { p1 }).should == 'Pp1'
+    lazy_eval(lambda { p1 }).must_equal 'Pp1'
   end
 
   it "resolves methods in the parent" do
-    lazy_eval(lambda { m1 }).should == 'Pm1'
+    lazy_eval(lambda { m1 }).must_equal 'Pm1'
   end
 
   it "resolves parameters in the parent's parent" do
-    lazy_eval(lambda { p2 }).should == 'PPp2'
+    lazy_eval(lambda { p2 }).must_equal 'PPp2'
   end
 
   it "resolves methods in the parent's parent" do
-    lazy_eval(lambda { m2 }).should == 'PPm2'
+    lazy_eval(lambda { m2 }).must_equal 'PPm2'
   end
 
   it "invokes methods in the parent" do
-    lazy_eval(lambda { echo(m1) }).should == ['P', 'Pm1']
+    lazy_eval(lambda { echo(m1) }).must_equal ['P', 'Pm1']
   end
 
   it "invokes methods in the parent's parent" do
-    lazy_eval(lambda { parent.echo(m1) }, { :m1 => 'o1'}).should == ['PP', 'o1']
+    lazy_eval(lambda { parent.echo(m1) }, { :m1 => 'o1'}).must_equal ['PP', 'o1']
   end
 
   it "invokes methods in the parent's parent" do
-    lazy_eval(lambda { echo2(m1) }).should == ['PP2', 'Pm1']
+    lazy_eval(lambda { echo2(m1) }).must_equal ['PP2', 'Pm1']
   end
 
   it "resolves parameters in preference to methods in the parent" do
-    lazy_eval(lambda { com }).should == 'PpC'
+    lazy_eval(lambda { com }).must_equal 'PpC'
   end
 
   it "resolves methods in the parent explicitly" do
-    lazy_eval(lambda { parent.m1 }).should == 'PPm1'
+    lazy_eval(lambda { parent.m1 }).must_equal 'PPm1'
   end
 
   it "cascades lambdas " do
-    lazy_eval(lambda { sym1 }).should == 'PPm2'
-    lazy_eval(lambda { sym2 }).should == 'PPm2'
+    lazy_eval(lambda { sym1 }).must_equal 'PPm2'
+    lazy_eval(lambda { sym2 }).must_equal 'PPm2'
   end
 
   it "does not resolve #index" do
-    expect { lazy_eval(lambda { index }) }.to raise_error(NoMethodError)
+    lambda { lazy_eval(lambda { index }) }.must_raise NoMethodError
   end
 end

data/test/offset_test.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe BinData::Base, "offsets" do
+  class ThreeByteReader < BinData::Base
+    def do_read(io)
+      @val = io.readbytes(3)
+    end
+
+    def snapshot
+      @val
+    end
+  end
+
+  class TenByteOffsetBase < BinData::Base
+    def self.create(params)
+      obj = self.new
+      obj.initialize_child(params)
+      obj
+    end
+
+    def initialize_child(params)
+      @child = ThreeByteReader.new(params, self)
+    end
+
+    def snapshot
+      @child.snapshot
+    end
+
+    def do_read(io)
+      io.seekbytes(10)
+      @child.do_read(io)
+    end
+
+    def clear
+    end
+  end
+
+  let(:data) { "0123456789abcdefghijk" }
+  let(:io) { StringIO.new(data) }
+
+  describe "with :check_offset" do
+    it "fails when offset is incorrect" do
+      io.seek(2)
+      obj = TenByteOffsetBase.create(:check_offset => 10 - 4)
+      lambda { obj.read(io) }.must_raise BinData::ValidityError
+    end
+
+    it "succeeds when offset is correct" do
+      io.seek(3)
+      obj = TenByteOffsetBase.create(:check_offset => 10)
+      obj.read(io).snapshot.must_equal data[3 + 10, 3]
+    end
+
+    it "fails when :check_offset fails" do
+      io.seek(4)
+      obj = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 + 1 } )
+      lambda { obj.read(io) }.must_raise BinData::ValidityError
+    end
+
+    it "succeeds when :check_offset succeeds" do
+      io.seek(5)
+      obj = TenByteOffsetBase.create(:check_offset => lambda { offset == 10 } )
+      obj.read(io).snapshot.must_equal data[5 + 10, 3]
+    end
+  end
+
+  describe "with :adjust_offset" do
+    it "is mutually exclusive with :check_offset" do
+      params = { :check_offset => 8, :adjust_offset => 8 }
+      lambda { TenByteOffsetBase.create(params) }.must_raise ArgumentError
+    end
+
+    it "adjust offset when incorrect" do
+      io.seek(2)
+      obj = TenByteOffsetBase.create(:adjust_offset => 13)
+      obj.read(io).snapshot.must_equal data[2 + 13, 3]
+    end
+
+    it "succeeds when offset is correct" do
+      io.seek(3)
+      obj = TenByteOffsetBase.create(:adjust_offset => 10)
+      obj.read(io).snapshot.must_equal data[3 + 10, 3]
+    end
+
+    it "fails if cannot adjust offset" do
+      io.seek(4)
+      obj = TenByteOffsetBase.create(:adjust_offset => -5)
+      lambda { obj.read(io) }.must_raise BinData::ValidityError
+    end
+  end
+end

data/test/params_test.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+
+describe BinData::Base, "parameters" do
+  it "fails when parameter name is invalid" do
+    lambda {
+      class InvalidParameterNameBase < BinData::Base
+        optional_parameter :eval # i.e. Kernel#eval
+      end
+    }.must_raise NameError
+  end
+
+  it "fails when parameter has nil value" do
+    lambda { BinData::Base.new(:a => nil) }.must_raise ArgumentError
+  end
+end
+
+describe BinData::Base, "#has_parameter?" do
+  it "true for existing parameters" do
+    obj = BinData::Base.new(:a => 3)
+    assert obj.has_parameter?(:a)
+  end
+
+  it "false for non-existing parameters" do
+    obj = BinData::Base.new
+    refute obj.has_parameter?(:a)
+  end
+end
+
+describe BinData::Base, "#get_parameter" do
+  it "retrieves parameter values" do
+    obj = BinData::Base.new(:a => 3)
+    obj.get_parameter(:a).must_equal 3
+  end
+
+  it "retrieves parameter values with string keys" do
+    obj = BinData::Base.new('a' => 3)
+    obj.get_parameter(:a).must_equal 3
+  end
+
+  it "returns nil for non existing parameters" do
+    obj = BinData::Base.new
+    obj.get_parameter(:a).must_be_nil
+  end
+
+  it "wont eval parameters" do
+    obj = BinData::Base.new(:a => lambda { 3 })
+    assert_kind_of Proc, obj.get_parameter(:a)
+  end
+end
+
+describe BinData::Base, "#eval_parameter" do
+  it "evals the parameter" do
+    obj = BinData::Base.new(:a => lambda { 3 })
+    obj.eval_parameter(:a).must_equal 3
+  end
+
+  it "returns nil for a non existing parameter" do
+    obj = BinData::Base.new
+    obj.eval_parameter(:a).must_be_nil
+  end
+end
+
+describe BinData::Base, ".mandatory_parameters" do
+  class MandatoryBase < BinData::Base
+    mandatory_parameter :p1
+    mandatory_parameter :p2
+  end
+
+  it "fails when not all mandatory parameters are present" do
+    params = {:p1 => "a", :xx => "b" }
+    lambda { MandatoryBase.new(params) }.must_raise ArgumentError
+  end
+
+  it "fails when no mandatory parameters are present" do
+    lambda { MandatoryBase.new() }.must_raise ArgumentError
+  end
+end
+
+describe BinData::Base, ".default_parameters" do
+  class DefaultBase < BinData::Base
+    default_parameter :p1 => "a"
+  end
+
+  it "uses default parameters when not specified" do
+    obj = DefaultBase.new
+    obj.eval_parameter(:p1).must_equal "a"
+  end
+
+  it "can override default parameters" do
+    obj = DefaultBase.new(:p1 => "b")
+    obj.eval_parameter(:p1).must_equal "b"
+  end
+end
+
+describe BinData::Base, ".mutually_exclusive_parameters" do
+  class MutexParamBase < BinData::Base
+    optional_parameters :p1, :p2, :p3
+    mutually_exclusive_parameters :p1, :p2, :p3
+  end
+
+  it "fails when any two of those parameters are present" do
+    lambda { MutexParamBase.new(:p1 => "a", :p2 => "b") }.must_raise ArgumentError
+    lambda { MutexParamBase.new(:p1 => "a", :p3 => "c") }.must_raise ArgumentError
+    lambda { MutexParamBase.new(:p2 => "b", :p3 => "c") }.must_raise ArgumentError
+  end
+end
+
+describe BinData::Base, "subclassing" do
+  class ParamLevel1Base < BinData::Base
+    optional_parameter :p1
+  end
+
+  class ParamLevel2Base < ParamLevel1Base
+    optional_parameter :p2
+  end
+
+  it "inherits parameters" do
+    accepted = ParamLevel2Base.accepted_parameters.all
+    accepted.must_include :p1
+    accepted.must_include :p2
+  end
+end
+
+describe BinData::Base, "subclassing when skipping a level" do
+  class ParamLevel1Base < BinData::Base
+    optional_parameter :p1
+  end
+
+  class ParamLevel2Base < ParamLevel1Base
+  end
+
+  class ParamLevel3Base < ParamLevel2Base
+    optional_parameter :p2
+  end
+
+  it "inherits parameters" do
+    accepted = ParamLevel3Base.accepted_parameters.all
+    accepted.must_include :p1
+    accepted.must_include :p2
+  end
+end

data/{spec/primitive_spec.rb → test/primitive_test.rb}

@@ -1,13 +1,12 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
 describe BinData::Primitive do
   it "is not registered" do
-    expect {
+    lambda {
       BinData::RegisteredClasses.lookup("Primitive")
-    }.to raise_error(BinData::UnRegisteredTypeError)
+    }.must_raise BinData::UnRegisteredTypeError
   end
 end
 
@@ -16,11 +15,11 @@ describe BinData::Primitive, "all subclasses" do
     expose_methods_for_testing
   end
 
-  subject { SubClassOfPrimitive.new }
+  let(:obj) { SubClassOfPrimitive.new }
 
   it "raise errors on unimplemented methods" do
-    expect { subject.set(nil) }.to raise_error(NotImplementedError)
-    expect { subject.get      }.to raise_error(NotImplementedError)
+    lambda { obj.set(nil) }.must_raise NotImplementedError
+    lambda { obj.get      }.must_raise NotImplementedError
   end
 end
 
@@ -30,9 +29,7 @@ describe BinData::Primitive, "when defining with errors" do
       class BadTypePrimitive < BinData::Primitive
         non_registered_type :a
       end
-    }.should raise_error_on_line(TypeError, 2) { |err|
-      err.message.should == "unknown type 'non_registered_type' in #{BadTypePrimitive}"
-    }
+    }.must_raise_on_line TypeError, 2, "unknown type 'non_registered_type' in BadTypePrimitive"
   end
 
   it "fails on duplicate names" do
@@ -42,9 +39,7 @@ describe BinData::Primitive, "when defining with errors" do
         int8 :b
         int8 :a
       end
-    }.should raise_error_on_line(SyntaxError, 4) { |err|
-      err.message.should == "duplicate field 'a' in #{DuplicateNamePrimitive}"
-    }
+    }.must_raise_on_line SyntaxError, 4, "duplicate field 'a' in DuplicateNamePrimitive"
   end
 
   it "fails when field name shadows an existing method" do
@@ -52,9 +47,7 @@ describe BinData::Primitive, "when defining with errors" do
       class ExistingNamePrimitive < BinData::Primitive
         int8 :object_id
       end
-    }.should raise_error_on_line(NameError, 2) { |err|
-      err.message.should == "field 'object_id' shadows an existing method in #{ExistingNamePrimitive}"
-    }
+    }.must_raise_on_line NameError, 2, "field 'object_id' shadows an existing method in ExistingNamePrimitive"
   end
 
   it "fails on unknown endian" do
@@ -62,9 +55,7 @@ describe BinData::Primitive, "when defining with errors" do
       class BadEndianPrimitive < BinData::Primitive
         endian 'a bad value'
       end
-    }.should raise_error_on_line(ArgumentError, 2) { |err|
-      err.message.should == "unknown value for endian 'a bad value' in #{BadEndianPrimitive}"
-    }
+    }.must_raise_on_line ArgumentError, 2, "unknown value for endian 'a bad value' in BadEndianPrimitive"
   end
 end
 
@@ -76,50 +67,51 @@ describe BinData::Primitive do
     def set(v); self.a = v; end
   end
 
-  subject { PrimitiveWithEndian.new }
+  let(:obj) { PrimitiveWithEndian.new }
 
   it "assigns value" do
-    subject.value = 5
-    subject.value.should == 5
+    obj.value = 5
+    obj.value.must_equal 5
   end
 
   it "produces binary string" do
-    subject.assign(5)
-    subject.to_binary_s.should == "\x05\x00"
+    obj.assign(5)
+    obj.to_binary_s.must_equal "\x05\x00"
   end
 
   it "reads value" do
-    subject.read("\x00\x01")
-    subject.should == 0x100
+    obj.read("\x00\x01")
+    obj.must_equal 0x100
   end
 
   it "accepts standard parameters" do
-    subject = PrimitiveWithEndian.new(:initial_value => 2)
-    subject.to_binary_s.should == "\x02\x00"
+    obj = PrimitiveWithEndian.new(:initial_value => 2)
+    obj.to_binary_s.must_equal "\x02\x00"
   end
 
   it "returns num_bytes" do
-    subject.num_bytes.should == 2
+    obj.num_bytes.must_equal 2
   end
 
   it "raises error on missing methods" do
-    expect {
-      subject.does_not_exist
-    }.to raise_error(NoMethodError)
+    lambda {
+      obj.does_not_exist
+    }.must_raise NoMethodError
   end
 
   it "uses read value whilst reading" do
-    subject = PrimitiveWithEndian.new(:value => 2)
-    subject.read "\x05\x00"
-    subject.should == 2
+    obj = PrimitiveWithEndian.new(:value => 2)
+    obj.read "\x05\x00"
+    obj.must_equal 2
 
-    subject.stub(:reading?).and_return(true)
-    subject.should == 5
+    obj.stub :reading?, true do
+      obj.must_equal 5
+    end
   end
 
   it "behaves as primitive" do
-    subject.assign(5)
-    (2 + subject).should == 7
+    obj.assign(5)
+    (2 + obj).must_equal 7
   end
 end
 
@@ -131,8 +123,8 @@ describe BinData::Primitive, "requiring custom parameters" do
   end
 
   it "passes parameters correctly" do
-    subject = PrimitiveWithCustom.new(:iv => 5)
-    subject.should == 5
+    obj = PrimitiveWithCustom.new(:iv => 5)
+    obj.must_equal 5
   end
 end
 
@@ -146,12 +138,12 @@ describe BinData::Primitive, "with custom mandatory parameters" do
   end
 
   it "raises error if mandatory parameter is not supplied" do
-    expect { MandatoryPrimitive.new }.to raise_error(ArgumentError)
+    lambda { MandatoryPrimitive.new }.must_raise ArgumentError
   end
 
   it "uses mandatory parameter" do
-    subject = MandatoryPrimitive.new(:arg1 => 5)
-    subject.should == 5
+    obj = MandatoryPrimitive.new(:arg1 => 5)
+    obj.must_equal 5
   end
 end
 
@@ -164,18 +156,14 @@ describe BinData::Primitive, "with custom default parameters" do
     def set(v); self.a = v; end
   end
 
-  it "does not raise error if default parameter is not supplied" do
-    expect { DefaultPrimitive.new }.not_to raise_error(ArgumentError)
-  end
-
   it "uses default parameter" do
-    subject = DefaultPrimitive.new
-    subject.should == 5
+    obj = DefaultPrimitive.new
+    obj.must_equal 5
   end
 
   it "overrides default parameter" do
-    subject = DefaultPrimitive.new(:arg1 => 7)
-    subject.should == 7
+    obj = DefaultPrimitive.new(:arg1 => 7)
+    obj.must_equal 7
   end
 end
 
@@ -192,11 +180,11 @@ describe BinData::Primitive, "subclassed with default parameter" do
 
   it "overrides initial_value" do
     a = ChildDerivedPrimitive.new(:initial_value => 7)
-    a.to_binary_s.should == "\000\007"
+    a.to_binary_s.must_equal "\000\007"
   end
 
   it "uses default parameter" do
     a = ChildDerivedPrimitive.new
-    a.to_binary_s.should == "\000\005"
+    a.to_binary_s.must_equal "\000\005"
   end
 end