bindata 0.9.3 → 0.10.0

data/spec/system_spec.rb

@@ -0,0 +1,291 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require File.expand_path(File.dirname(__FILE__)) + '/example'
+require 'bindata'
+
+describe "lambdas with index" do
+  before(:all) do
+    eval <<-END
+      class NestedLambdaWithIndex < BinData::Record
+        uint8 :a, :value => lambda { index * 10 }
+      end
+    END
+  end
+
+  it "should use index of containing array" do
+    arr = BinData::Array.new(:type =>
+                               [:uint8, { :value => lambda { index * 10 } }],
+                             :initial_length => 3)
+    arr.snapshot.should == [0, 10, 20]
+  end
+
+  it "should use index of nearest containing array" do
+    arr = BinData::Array.new(:type => :nested_lambda_with_index,
+                             :initial_length => 3)
+    arr.snapshot.should == [{"a" => 0}, {"a" => 10}, {"a" => 20}]
+  end
+
+  it "should fail if there is no containing array" do
+    obj = NestedLambdaWithIndex.new
+    lambda { obj.a.value }.should raise_error(NoMethodError)
+  end
+end
+
+describe "lambdas with parent" do
+  it "should access immediate parent when no parent is specified" do
+    class NestedLambdaWithoutParent < BinData::Record
+      int8 :a, :value => 5
+      int8 :b, :value => lambda { a }
+    end
+
+    class TestLambdaWithoutParent < BinData::Record
+      int8   :a, :value => 3
+      nested_lambda_without_parent :x
+    end
+
+    obj = TestLambdaWithoutParent.new
+    obj.x.b.should == 5
+  end
+
+  it "should access parent's parent when parent is specified" do
+    class NestedLambdaWithParent < BinData::Record
+      int8 :a, :value => 5
+      int8 :b, :value => lambda { parent.a }
+    end
+
+    class TestLambdaWithParent < BinData::Record
+      int8   :a, :value => 3
+      nested_lambda_with_parent :x
+    end
+
+    obj = TestLambdaWithParent.new
+    obj.x.b.should == 3
+  end
+end
+
+describe "Records with choice field" do
+  before(:all) do
+    eval <<-END
+      class TupleRecord < BinData::Record
+        uint8 :a, :value => 3
+        uint8 :b, :value => 5
+      end
+
+      class RecordWithChoiceField < BinData::Record
+        choice :x, :choices => [[:tuple_record]], :selection => 0
+      end
+
+      class RecordWithNestedChoiceField < BinData::Record
+        choice :x, :choices => [
+                      [:choice, {
+                          :choices => [[:tuple_record]],
+                          :selection => 0}
+                      ]
+                   ],
+                   :selection => 0
+      end
+    END
+  end
+
+  it "should treat choice object transparently " do
+    obj = RecordWithChoiceField.new
+
+    obj.x.a.should == 3
+  end
+
+  it "should treat nested choice object transparently " do
+    obj = RecordWithNestedChoiceField.new
+
+    obj.x.a.should == 3
+  end
+
+  it "should have correct offset" do
+    obj = RecordWithNestedChoiceField.new
+    obj.x.b.offset.should == 1
+  end
+end
+
+describe BinData::Array, "of bits" do
+  before(:each) do
+    @data = BinData::Array.new(:type => :bit1, :initial_length => 15)
+  end
+
+  it "should read" do
+    str = [0b0001_0100, 0b1000_1000].pack("CC")
+    @data.read(str)
+    @data[0].should  == 0
+    @data[1].should  == 0
+    @data[2].should  == 0
+    @data[3].should  == 1
+    @data[4].should  == 0
+    @data[5].should  == 1
+    @data[6].should  == 0
+    @data[7].should  == 0
+    @data[8].should  == 1
+    @data[9].should  == 0
+    @data[10].should == 0
+    @data[11].should == 0
+    @data[12].should == 1
+    @data[13].should == 0
+    @data[14].should == 0
+  end
+
+  it "should write" do
+    @data[3] = 1
+    @data.to_binary_s.should == [0b0001_0000, 0b0000_0000].pack("CC")
+  end
+
+  it "should return num_bytes" do
+    @data.num_bytes.should == 2
+  end
+
+  it "should have correct offset" do
+    @data[7].offset.should == 0
+    @data[8].offset.should == 1
+  end
+end
+
+describe "Objects with debug_name" do
+  it "should have default name of obj" do
+    el = ExampleSingle.new
+    el.debug_name.should == "obj"
+  end
+
+  it "should include array index" do
+    arr = BinData::Array.new(:type => :example_single, :initial_length => 2)
+    arr[2].debug_name.should == "obj[2]"
+  end
+
+  it "should include field name" do
+    s = BinData::Struct.new(:fields => [[:example_single, :a]])
+    s.a.debug_name.should == "obj.a"
+  end
+
+  it "should delegate to choice" do
+    choice_params = {:choices => [:example_single], :selection => 0}
+    s = BinData::Struct.new(:fields => [[:choice, :a, choice_params]])
+    s.a.debug_name.should == "obj.a"
+  end
+
+  it "should nest" do
+    nested_struct_params = {:fields => [[:example_single, :c]]}
+    struct_params = {:fields => [[:struct, :b, nested_struct_params]]}
+    s = BinData::Struct.new(:fields => [[:struct, :a, struct_params]])
+    s.a.b.c.debug_name.should == "obj.a.b.c"
+  end
+end
+
+describe "Tracing"  do
+  it "should trace arrays" do
+    arr = BinData::Array.new(:type => :int8, :initial_length => 5)
+
+    io = StringIO.new
+    BinData::trace_reading(io) { arr.read("\x01\x02\x03\x04\x05") }
+    io.rewind
+
+    expected = (0..4).collect { |i| "obj[#{i}] => #{i + 1}\n" }.join("")
+    io.read.should == expected
+  end
+
+  it "should trace custom single values" do
+    class DebugNamePrimitive < BinData::Primitive
+      int8 :ex
+      def get;     self.ex; end
+      def set(val) self.ex = val; end
+    end
+
+    obj = DebugNamePrimitive.new
+
+    io = StringIO.new
+    BinData::trace_reading(io) { obj.read("\x01") }
+    io.rewind
+
+    io.read.should == ["obj-internal-.ex => 1\n", "obj => 1\n"].join("")
+  end
+
+  it "should trace choice selection" do
+    obj = BinData::Choice.new(:choices => [:int8, :int16be], :selection => 0)
+
+    io = StringIO.new
+    BinData::trace_reading(io) { obj.read("\x01") }
+    io.rewind
+
+    io.read.should == ["obj-selection- => 0\n", "obj => 1\n"].join("")
+  end
+end
+
+describe "Forward referencing with Single" do
+  before(:all) do
+    eval <<-END
+      class FRSingle < BinData::Record
+        uint8  :len, :value => lambda { data.length }
+        string :data, :read_length => :len
+      end
+    END
+  end
+
+  it "should initialise" do
+    @obj = FRSingle.new
+    @obj.snapshot.should == {"len" => 0, "data" => ""}
+  end
+
+  it "should read" do
+    @obj = FRSingle.new
+    @obj.read("\x04test")
+    @obj.snapshot.should == {"len" => 4, "data" => "test"}
+  end
+
+  it "should set value" do
+    @obj = FRSingle.new
+    @obj.data = "hello"
+    @obj.snapshot.should == {"len" => 5, "data" => "hello"}
+  end
+end
+
+describe "Forward referencing with Array" do
+  before(:all) do
+    eval <<-END
+      class FRArray < BinData::Record
+        uint8  :len, :value => lambda { data.length }
+        array :data, :type => :uint8, :initial_length => :len
+      end
+    END
+  end
+
+  it "should initialise" do
+    @obj = FRArray.new
+    @obj.snapshot.should == {"len" => 0, "data" => []}
+  end
+
+  it "should read" do
+    @obj = FRArray.new
+    @obj.read("\x04\x01\x02\x03\x04")
+    @obj.snapshot.should == {"len" => 4, "data" => [1, 2, 3, 4]}
+  end
+
+  it "should set value" do
+    @obj = FRArray.new
+    @obj.data = [1, 2, 3]
+    @obj.snapshot.should == {"len" => 3, "data" => [1, 2, 3]}
+  end
+end
+
+describe "Evaluating custom parameters" do
+  before(:all) do
+    eval <<-END
+      class CustomParameterRecord < BinData::Record
+        mandatory_parameter :zz
+
+        uint8 :a, :value => :zz
+        uint8 :b, :value => :a
+        uint8 :c, :custom => :b
+      end
+    END
+  end
+
+  it "should recursively evaluate parameter" do
+    obj = CustomParameterRecord.new(:zz => 5)
+    obj.c.eval_parameter(:custom).should == 5
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bindata
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  version: 0.10.0
 platform: ruby
 authors: 
 - Dion Mendel
@@ -9,7 +9,7 @@ autorequire: bindata
 bindir: bin
 cert_chain: []
 
-date: 2008-12-03 00:00:00 +09:00
+date: 2009-04-17 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -26,38 +26,42 @@ files:
 - INSTALL
 - README
 - GPL
+- NEWS
 - TODO
 - COPYING
 - examples/gzip.rb
 - spec/float_spec.rb
-- spec/single_value_spec.rb
 - spec/base_spec.rb
 - spec/sanitize_spec.rb
 - spec/lazy_spec.rb
 - spec/io_spec.rb
 - spec/choice_spec.rb
+- spec/base_primitive_spec.rb
 - spec/array_spec.rb
 - spec/stringz_spec.rb
-- spec/multi_value_spec.rb
+- spec/primitive_spec.rb
+- spec/example.rb
+- spec/system_spec.rb
 - spec/int_spec.rb
 - spec/string_spec.rb
 - spec/struct_spec.rb
 - spec/spec_common.rb
-- spec/single_spec.rb
 - spec/bits_spec.rb
 - spec/registry_spec.rb
 - spec/rest_spec.rb
+- spec/record_spec.rb
 - lib/bindata
 - lib/bindata/params.rb
-- lib/bindata/single.rb
 - lib/bindata/int.rb
 - lib/bindata/choice.rb
+- lib/bindata/trace.rb
 - lib/bindata/registry.rb
-- lib/bindata/single_value.rb
+- lib/bindata/base_primitive.rb
 - lib/bindata/struct.rb
 - lib/bindata/stringz.rb
-- lib/bindata/multi_value.rb
 - lib/bindata/bits.rb
+- lib/bindata/record.rb
+- lib/bindata/primitive.rb
 - lib/bindata/rest.rb
 - lib/bindata/base.rb
 - lib/bindata/array.rb

data/spec/single_value_spec.rb

@@ -1,131 +0,0 @@
-#!/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