bindata 0.9.3 → 0.10.0

data/spec/{multi_value_spec.rb → record_spec.rb}

@@ -3,46 +3,20 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata'
 
-describe BinData::MultiValue, "with hidden fields" do
-  before(:all) do
-    eval <<-END
-      class HiddenMultiValue < BinData::MultiValue
-        hide :b, 'c'
-        int8 :a
-        int8 'b', :initial_value => 10
-        int8 :c
-        int8 :d, :value => :b
-      end
-    END
-  end
-
-  before(:each) do
-    @obj = HiddenMultiValue.new
-  end
-
-  it "should only show fields that aren't hidden" do
-    @obj.field_names.should == ["a", "d"]
-  end
-
-  it "should be able to access hidden fields directly" do
-    @obj.b.should == 10
-    @obj.c = 15
-    @obj.c.should == 15
-
-    @obj.should respond_to(:b=)
+describe BinData::Record, "when defining" do
+  it "should allow inheriting from deprecated MultiValue" do
+    lambda {
+      eval <<-END
+        class SubclassMultiValue < BinData::MultiValue
+        end
+      END
+    }.should_not raise_error
   end
 
-  it "should not include hidden fields in snapshot" do
-    @obj.b = 5
-    @obj.snapshot.should == {"a" => 0, "d" => 5}
-  end
-end
-
-describe BinData::MultiValue, "when defining" do
   it "should fail on non registered types" do
     lambda {
       eval <<-END
-        class BadTypeMultiValue < BinData::MultiValue
+        class BadTypeRecord < BinData::Record
           non_registerd_type :a
         end
       END
@@ -52,7 +26,7 @@ describe BinData::MultiValue, "when defining" do
   it "should fail on duplicate names" do
     lambda {
       eval <<-END
-        class DuplicateNameMultiValue < BinData::MultiValue
+        class DuplicateNameRecord < BinData::Record
           int8 :a
           int8 :b
           int8 :a
@@ -64,7 +38,7 @@ describe BinData::MultiValue, "when defining" do
   it "should fail on reserved names" do
     lambda {
       eval <<-END
-        class ReservedNameMultiValue < BinData::MultiValue
+        class ReservedNameRecord < BinData::Record
           int8 :a
           int8 :invert # from Hash.instance_methods
         end
@@ -75,7 +49,7 @@ describe BinData::MultiValue, "when defining" do
   it "should fail when field name shadows an existing method" do
     lambda {
       eval <<-END
-        class ExistingNameMultiValue < BinData::MultiValue
+        class ExistingNameRecord < BinData::Record
           int8 :object_id
         end
       END
@@ -85,7 +59,7 @@ describe BinData::MultiValue, "when defining" do
   it "should fail on unknown endian" do
     lambda {
       eval <<-END
-        class BadEndianMultiValue < BinData::MultiValue
+        class BadEndianRecord < BinData::Record
           endian 'a bad value'
         end
       END
@@ -93,10 +67,45 @@ describe BinData::MultiValue, "when defining" do
   end
 end
 
-describe BinData::MultiValue, "with multiple fields" do
+describe BinData::Record, "with hidden fields" do
+  before(:all) do
+    eval <<-END
+      class HiddenRecord < BinData::Record
+        hide :b, 'c'
+        int8 :a
+        int8 'b', :initial_value => 10
+        int8 :c
+        int8 :d, :value => :b
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = HiddenRecord.new
+  end
+
+  it "should only show fields that aren't hidden" do
+    @obj.field_names.should == ["a", "d"]
+  end
+
+  it "should be able to access hidden fields directly" do
+    @obj.b.should == 10
+    @obj.c = 15
+    @obj.c.should == 15
+
+    @obj.should respond_to(:b=)
+  end
+
+  it "should not include hidden fields in snapshot" do
+    @obj.b = 5
+    @obj.snapshot.should == {"a" => 0, "d" => 5}
+  end
+end
+
+describe BinData::Record, "with multiple fields" do
   before(:all) do
     eval <<-END
-      class MultiFieldMultiValue < BinData::MultiValue
+      class MultiFieldRecord < BinData::Record
         int8 :a
         int8 :b
       end
@@ -104,7 +113,7 @@ describe BinData::MultiValue, "with multiple fields" do
   end
 
   before(:each) do
-    @obj = MultiFieldMultiValue.new
+    @obj = MultiFieldRecord.new
     @obj.a = 1
     @obj.b = 2
   end
@@ -116,35 +125,30 @@ describe BinData::MultiValue, "with multiple fields" do
   end
 
   it "should identify accepted parameters" do
-    BinData::MultiValue.internal_parameters.should include(:hide)
-    BinData::MultiValue.internal_parameters.should include(:endian)
+    BinData::Record.accepted_internal_parameters.should include(:hide)
+    BinData::Record.accepted_internal_parameters.should include(:endian)
   end
 
   it "should clear" do
     @obj.a = 6
     @obj.clear
-    @obj.clear?.should be_true
+    @obj.should be_clear
   end
 
   it "should clear individual elements" do
     @obj.a = 6
     @obj.b = 7
     @obj.clear(:a)
-    @obj.clear?(:a).should be_true
-    @obj.clear?(:b).should be_false
+    @obj.should be_clear(:a)
+    @obj.should_not be_clear(:b)
   end
 
   it "should write ordered" do
-    io = StringIO.new
-    @obj.write(io)
-
-    io.rewind
-    io.read.should == "\x01\x02"
+    @obj.to_binary_s.should == "\x01\x02"
   end
 
   it "should read ordered" do
-    io = StringIO.new "\x03\x04"
-    @obj.read(io)
+    @obj.read("\x03\x04")
 
     @obj.a.should == 3
     @obj.b.should == 4
@@ -166,29 +170,29 @@ describe BinData::MultiValue, "with multiple fields" do
   end
 end
 
-describe BinData::MultiValue, "with nested structs" do
+describe BinData::Record, "with nested structs" do
   before(:all) do
     eval <<-END
-      class MultiValueInner1 < BinData::MultiValue
+      class Inner1Record < BinData::Record
         int8 :w, :initial_value => 3
         int8 :x, :value => :the_val
       end
 
-      class MultiValueInner2 < BinData::MultiValue
+      class Inner2Record < BinData::Record
         int8 :y, :value => lambda { parent.b.w }
         int8 :z
       end
 
-      class MultiValueOuter < BinData::MultiValue
+      class RecordOuter < BinData::Record
         int8               :a, :initial_value => 6
-        multi_value_inner1 :b, :the_val => :a
-        multi_value_inner2 :c
+        inner1_record :b, :the_val => :a
+        inner2_record :c
       end
     END
   end
 
   before(:each) do
-    @obj = MultiValueOuter.new
+    @obj = RecordOuter.new
   end
 
   it "should included nested field names" do
@@ -202,16 +206,18 @@ describe BinData::MultiValue, "with nested structs" do
     @obj.c.y.should == 3
   end
 
-  it "should return correct offset of" do
-    @obj.offset_of("b").should == 1
-    @obj.offset_of("c").should == 3
+  it "should return correct offset" do
+    @obj.b.offset.should == 1
+    @obj.b.w.offset.should == 1
+    @obj.c.offset.should == 3
+    @obj.c.z.offset.should == 4
   end
 end
 
-describe BinData::MultiValue, "with an endian defined" do
+describe BinData::Record, "with an endian defined" do
   before(:all) do
     eval <<-END
-      class MultiValueWithEndian < BinData::MultiValue
+      class RecordWithEndian < BinData::Record
         endian :little
 
         uint16 :a
@@ -225,7 +231,7 @@ describe BinData::MultiValue, "with an endian defined" do
   end
 
   before(:each) do
-    @obj = MultiValueWithEndian.new
+    @obj = RecordWithEndian.new
   end
 
   it "should use correct endian" do
@@ -240,58 +246,54 @@ describe BinData::MultiValue, "with an endian defined" do
 
     expected = [1, 2.0, 3, 4, 5, 6, 7, 8].pack('veCCVvNv')
 
-    io = StringIO.new
-    @obj.write(io)
-
-    io.rewind
-    io.read.should == expected
+    @obj.to_binary_s.should == expected
   end
 end
 
-describe BinData::MultiValue, "defined recursively" do
+describe BinData::Record, "defined recursively" do
   before(:all) do
     eval <<-END
-      class RecursiveMultiValue < BinData::MultiValue
+      class RecursiveRecord < BinData::Record
         endian  :big
         uint16  :val
         uint8   :has_nxt, :value => lambda { nxt.clear? ? 0 : 1 }
-        recursive_multi_value :nxt, :onlyif => lambda { has_nxt > 0 }
+        recursive_record :nxt, :onlyif => lambda { has_nxt > 0 }
       end
     END
   end
 
   it "should be able to be created" do
-    obj = RecursiveMultiValue.new
+    obj = RecursiveRecord.new
   end
 
   it "should read" do
     str = "\x00\x01\x01\x00\x02\x01\x00\x03\x00"
-    obj = RecursiveMultiValue.read(str)
+    obj = RecursiveRecord.read(str)
     obj.val.should == 1
     obj.nxt.val.should == 2
     obj.nxt.nxt.val.should == 3
   end
 
   it "should be assignable on demand" do
-    obj = RecursiveMultiValue.new
+    obj = RecursiveRecord.new
     obj.val = 13
     obj.nxt.val = 14
     obj.nxt.nxt.val = 15
   end
 
   it "should write" do
-    obj = RecursiveMultiValue.new
+    obj = RecursiveRecord.new
     obj.val = 5
     obj.nxt.val = 6
     obj.nxt.nxt.val = 7
-    obj.to_s.should == "\x00\x05\x01\x00\x06\x01\x00\x07\x00"
+    obj.to_binary_s.should == "\x00\x05\x01\x00\x06\x01\x00\x07\x00"
   end
 end
 
-describe BinData::MultiValue, "with custom mandatory parameters" do
+describe BinData::Record, "with custom mandatory parameters" do
   before(:all) do
     eval <<-END
-      class MandatoryMultiValue < BinData::MultiValue
+      class MandatoryRecord < BinData::Record
         mandatory_parameter :arg1
 
         uint8 :a, :value => :arg1
@@ -300,19 +302,19 @@ describe BinData::MultiValue, "with custom mandatory parameters" do
   end
 
   it "should raise error if mandatory parameter is not supplied" do
-    lambda { MandatoryMultiValue.new }.should raise_error(ArgumentError)
+    lambda { MandatoryRecord.new }.should raise_error(ArgumentError)
   end
 
   it "should use mandatory parameter" do
-    obj = MandatoryMultiValue.new(:arg1 => 5)
+    obj = MandatoryRecord.new(:arg1 => 5)
     obj.a.should == 5
   end
 end
 
-describe BinData::MultiValue, "with custom default parameters" do
+describe BinData::Record, "with custom default parameters" do
   before(:all) do
     eval <<-END
-      class DefaultMultiValue < BinData::MultiValue
+      class DefaultRecord < BinData::Record
         default_parameter :arg1 => 5
 
         uint8 :a, :value => :arg1
@@ -321,16 +323,49 @@ describe BinData::MultiValue, "with custom default parameters" do
   end
 
   it "should not raise error if default parameter is not supplied" do
-    lambda { DefaultMultiValue.new }.should_not raise_error(ArgumentError)
+    lambda { DefaultRecord.new }.should_not raise_error(ArgumentError)
   end
 
   it "should use default parameter" do
-    obj = DefaultMultiValue.new
+    obj = DefaultRecord.new
     obj.a.should == 5
   end
 
   it "should be able to override default parameter" do
-    obj = DefaultMultiValue.new(:arg1 => 7)
+    obj = DefaultRecord.new(:arg1 => 7)
     obj.a.should == 7
   end
 end
+
+describe BinData::Record, "with :onlyif" do
+  before(:all) do
+    eval <<-END
+      class OnlyIfRecord < BinData::Record
+        uint8 :a, :initial_value => 3
+        uint8 :b, :initial_value => 5, :onlyif => lambda { a == 3 }
+        uint8 :c, :initial_value => 7, :onlyif => lambda { a != 3 }
+      end
+    END
+  end
+
+  before(:each) do
+    @obj = OnlyIfRecord.new
+  end
+
+  it "should have correct num_bytes" do
+    @obj.num_bytes.should == 2
+  end
+
+  it "should have expected snapshot" do
+    @obj.snapshot.should == {"a" => 3, "b" => 5}
+  end
+
+  it "should read as expected" do
+    @obj.read("\x01\x02")
+    @obj.snapshot.should == {"a" => 1, "c" => 2}
+  end
+
+  it "should write as expected" do
+    @obj.to_binary_s.should == "\x03\x05"
+  end
+end

data/spec/registry_spec.rb

@@ -4,17 +4,28 @@ require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/registry'
 
 describe BinData::Registry do
+  before(:all) do
+    A = Class.new
+    B = Class.new
+    C = Class.new
+    D = Class.new
+  end
+
   before(:each) do
-    @r = BinData::Registry.instance
+    @r = BinData::Registry.new
   end
 
-  it "should be a singleton" do
-    BinData::Registry.instance.should == BinData::Registry.instance
+  it "should determine if a name is registered" do
+    @r.register('A', A)
+
+    @r.is_registered?('a').should be_true
+  end
+
+  it "should determine if a name is not registered" do
+    @r.is_registered?('xyz').should be_false
   end
 
   it "should lookup registered names" do
-    A = Class.new
-    B = Class.new
     @r.register('ASubClass', A)
     @r.register('AnotherSubClass', B)
 
@@ -26,22 +37,52 @@ describe BinData::Registry do
     @r.lookup('a_non_existent_sub_class').should be_nil
   end
 
+  it "should allow 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
-    @r.register('CamelCase', A).should == 'camel_case'
+    @r.underscore_name('CamelCase').should == 'camel_case'
   end
 
   it "should convert adjacent caps camelCase to underscores" do
-    @r.register('XYZCamelCase', A).should == 'xyz_camel_case'
+    @r.underscore_name('XYZCamelCase').should == 'xyz_camel_case'
   end
 
   it "should ignore the outer nestings of classes" do
-    @r.register('A::B::C', A).should == 'c'
+    @r.underscore_name('A::B::C').should == 'c'
   end
 
-  it "should allow overriding of registered classes" do
-    @r.register('A', A)
-    @r.register('A', B)
+  it "should lookup integers with endian" do
+#    @r.register("Int24be", A)
+#    @r.register("Int24le", B)
+#    @r.register("Uint24be", C)
+#    @r.register("Uint24le", D)
+#
+#    @r.lookup("int24", :big).should == A
+#    @r.lookup("int24", :little).should == B
+#    @r.lookup("uint24", :big).should == C
+#    @r.lookup("uint24", :little).should == D
+  end
 
-    @r.lookup('a').should == B
+  it "should not lookup integers without endian" do
+#    @r.register("Int24be", A)
+
+#    @r.lookup("int24").should be_nil
+  end
+
+  it "should lookup floats with endian" do
+#    @r.register("FloatBe", A)
+#    @r.register("FloatLe", B)
+#    @r.register("DoubleBe", C)
+#    @r.register("DoubleLe", D)
+#
+#    @r.lookup("float", :big).should == A
+#    @r.lookup("float", :little).should == B
+#    @r.lookup("double", :big).should == C
+#    @r.lookup("double", :little).should == D
   end
 end