bindata 0.9.3 → 0.10.0

data/spec/rest_spec.rb

@@ -17,14 +17,13 @@ describe BinData::Rest do
     rest = BinData::Rest.new
     rest.value = "123"
     rest.value.should == "123"
-    rest.to_s.should == "123"
+    rest.to_binary_s.should == "123"
   end
 
-  it "should accept BinData::Single parameters" do
+  it "should accept BinData::BasePrimitive 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

@@ -4,76 +4,17 @@ require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/sanitize'
 require 'bindata/int'
 
-describe BinData::Sanitizer, "class methods" do
-  it "should resolve type with endian" do
-    BinData::Sanitizer.type_exists?(:int16, :little).should be_true
-  end
-
-  it "should return if type exists" do
-    BinData::Sanitizer.type_exists?(:int8).should be_true
-  end
-
-  it "should raise if type doesn't exist" do
-    BinData::Sanitizer.type_exists?(:does_not_exist).should be_false
-  end
-
-  it "should lookup types" do
-    BinData::Sanitizer.lookup(:int16, :little).should == BinData::Int16le
-  end
-
-end
-
-describe BinData::Sanitizer do
-  before(:each) do
-    @sanitizer = BinData::Sanitizer.new
-  end
-
-  it "should raise error on unknown types" do
-    lambda {
-      @sanitizer.lookup_klass(:does_not_exist)
-    }.should raise_error(TypeError)
-  end
-
-  it "should lookup when endian is set" do
-    @sanitizer.with_endian(:little) do
-      klass = @sanitizer.lookup_klass(:int16)
-      klass.should == BinData::Int16le
-    end
-  end
-
-  it "should nest with_endian calls" do
-    @sanitizer.with_endian(:little) do
-      klass = @sanitizer.lookup_klass(:int16)
-      klass.should == BinData::Int16le
-
-      @sanitizer.with_endian(:big) do
-        klass = @sanitizer.lookup_klass(:int16)
-        klass.should == BinData::Int16be
-      end
-
-      klass = @sanitizer.lookup_klass(:int16)
-      klass.should == BinData::Int16le
-    end
-  end
-
-  it "should sanitize parameters" do
-    params = @sanitizer.sanitize_params(BinData::Int8, {:value => 3})
-    params.should have_key(:value)
-  end
-end
-
 describe BinData::SanitizedParameters, "with bad input" do
   before(:each) do
     @mock = mock("dummy class")
-    @mock.stub!(:internal_parameters).and_return([:a, :b, :c])
+    @mock.stub!(:accepted_internal_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}
     sanitized = BinData::SanitizedParameters.new(@mock, the_params)
-    sanitized.internal_parameters.should == ({:a => 1, :b => 2})
-    sanitized.extra_parameters.should == ({:e => 5})
+    sanitized.parameters.should == {:a => 1, :b => 2, :e => 5}
   end
 
   it "should raise error if parameter has nil value" do
@@ -87,29 +28,23 @@ end
 describe BinData::SanitizedParameters do
   before(:each) do
     @mock = mock("dummy class")
-    @mock.stub!(:internal_parameters).and_return([:a, :b, :c])
+    @mock.stub!(:accepted_internal_parameters).and_return([:a, :b, :c])
     @params = {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
   end
 
-  it "should partition" do
-    sanitized = BinData::SanitizedParameters.new(@mock, @params)
-    sanitized.internal_parameters.should == ({:a => 1, :b => 2, :c => 3})
-    sanitized.extra_parameters.should == ({:d => 4, :e => 5})
-  end
-
   it "should respond_to keys" do
     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'])
+    keys = sanitized.keys.collect { |k| k.to_s }
+    keys.sort.should == ['a', 'b', 'c', 'd', 'e']
   end
 
   it "should respond_to has_key?" do
     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
+    sanitized.should have_key(:a)
+    sanitized.should have_key(:e)
+    sanitized.should_not have_key(:z)
   end
 
   it "should respond_to []" do
@@ -119,3 +54,42 @@ describe BinData::SanitizedParameters do
     sanitized[:d].should == 4
   end
 end
+
+describe BinData::Sanitizer do
+  before(:each) do
+    @sanitizer = BinData::Sanitizer.new
+  end
+
+  it "should raise error on unknown types" do
+    lambda {
+      @sanitizer.lookup_class(:does_not_exist)
+    }.should raise_error(TypeError)
+  end
+
+  it "should lookup when endian is set" do
+    @sanitizer.with_endian(:little) do
+      the_class = @sanitizer.lookup_class(:int16)
+      the_class.should == BinData::Int16le
+    end
+  end
+
+  it "should nest with_endian calls" do
+    @sanitizer.with_endian(:little) do
+      the_class = @sanitizer.lookup_class(:int16)
+      the_class.should == BinData::Int16le
+
+      @sanitizer.with_endian(:big) do
+        the_class = @sanitizer.lookup_class(:int16)
+        the_class.should == BinData::Int16be
+      end
+
+      the_class = @sanitizer.lookup_class(:int16)
+      the_class.should == BinData::Int16le
+    end
+  end
+
+  it "should sanitize parameters" do
+    params = @sanitizer.sanitized_params(BinData::Int8, {:value => 3})
+    params.should have_key(:value)
+  end
+end

data/spec/spec_common.rb

@@ -2,9 +2,21 @@ $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
 
 begin
   require 'rubygems'
-  gem 'rspec', '> 0.9.0'
+  gem 'rspec', '> 1.2.2'
 rescue LoadError
 end
 
 require 'spec'
+require 'spec/autorun'
 require 'stringio'
+
+class Object
+  def expose_methods_for_testing
+    cls = (Class === self) ? self : (class << self ; self; end)
+    private_method_names = cls.private_instance_methods - Object.private_instance_methods
+    cls.send(:public, *private_method_names)
+
+    protected_method_names = cls.protected_instance_methods - Object.protected_instance_methods
+    cls.send(:public, *protected_method_names)
+  end
+end

data/spec/string_spec.rb

@@ -22,14 +22,30 @@ describe BinData::String, "with mutually exclusive parameters" do
 end
 
 describe BinData::String, "with deprecated parameters" do
-  it "should substitude :read_length for :initial_length" do
-    obj = BinData::String.new(:initial_length => 3)
-    io = StringIO.new("abcdefghij")
-    obj.read(io)
+  it "should substitude :trim_padding for :trim_value" do
+    obj = BinData::String.new(:trim_value => true)
+    obj.value = "abc\0"
     obj.value.should == "abc"
   end
 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
+
+  it "should copy data from small to large" do
+    @large.value = @small
+    @large.value.should == "AAABB"
+  end
+
+  it "should copy data from large to small" do
+    @small.value = @large
+    @small.value.should == "BBB"
+  end
+end
+
 describe BinData::String, "with :read_length" do
   before(:each) do
     @str = BinData::String.new(:read_length => 5)
@@ -41,8 +57,7 @@ describe BinData::String, "with :read_length" do
   end
 
   it "should read :read_length bytes" do
-    io = StringIO.new("abcdefghij")
-    @str.read(io)
+    @str.read("abcdefghij")
     @str.value.should == "abcde"
   end
 
@@ -50,8 +65,8 @@ describe BinData::String, "with :read_length" do
     @str.value = "abc"
     @str.num_bytes.should == 3
     @str.clear
-    io = StringIO.new("abcdefghij")
-    @str.read(io)
+
+    @str.read("abcdefghij")
     @str.value.should == "abcde"
   end
 end
@@ -75,8 +90,7 @@ describe BinData::String, "with :length" do
   end
 
   it "should read :length bytes" do
-    io = StringIO.new("abcdefghij")
-    @str.read(io)
+    @str.read("abcdefghij")
     @str.value.should == "abcde"
   end
 
@@ -113,8 +127,7 @@ describe BinData::String, "with :read_length and :initial_value" do
    end
 
   it "should forget :initial_value after reading" do
-    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-    @str.read(io)
+    @str.read("ABCDEFGHIJKLMNOPQRST")
     @str.num_bytes.should == 5
     @str.value.should == "ABCDE"
   end
@@ -124,6 +137,7 @@ end
 describe BinData::String, "with :read_length and :value" do
   before(:each) do
     @str = BinData::String.new(:read_length => 5, :value => "abcdefghij")
+    @str.expose_methods_for_testing
   end
 
   it "should not be affected by :read_length before value is read" do
@@ -138,16 +152,13 @@ describe BinData::String, "with :read_length and :value" do
    end
 
   it "should not be affected by :read_length after reading" do
-    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-    @str.read(io)
+    @str.read("ABCDEFGHIJKLMNOPQRST")
     @str.num_bytes.should == 10
     @str.value.should == "abcdefghij"
   end
 
   it "should return read value before calling done_read" do
-    io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
-
-    @str.do_read(BinData::IO.new(io))
+    @str.do_read(BinData::IO.new("ABCDEFGHIJKLMNOPQRST"))
     @str.value.should == "ABCDE"
 
     @str.done_read
@@ -193,10 +204,10 @@ describe BinData::String, "with :pad_char" do
   end
 end
 
-describe BinData::String, "with :trim_value" do
+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_value => false)
+    str2 = BinData::String.new(:length => 5, :trim_padding => false)
     str1.value = "abc"
     str2.value = "abc"
     str1.value.should == "abc\0\0"
@@ -204,25 +215,25 @@ describe BinData::String, "with :trim_value" do
   end
 
   it "should trim the value" do
-    str = BinData::String.new(:pad_char => 'R', :trim_value => true)
+    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_value => true)
+    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_value => true)
+    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_value => true)
+    str = BinData::String.new(:pad_char => 'R', :trim_padding => true)
     str.value = "abcRRde"
     str.value.should == "abcRRde"
   end

data/spec/stringz_spec.rb

@@ -17,10 +17,7 @@ describe BinData::Stringz, "when empty" do
   end
 
   it "should write the zero byte terminator" do
-    io = StringIO.new
-    @str.write(io)
-    io.rewind
-    io.read.should == "\0"
+    @str.to_binary_s.should == "\0"
   end
 end
 
@@ -39,10 +36,7 @@ describe BinData::Stringz, "with value set" do
   end
 
   it "should write the zero byte terminator" do
-    io = StringIO.new
-    @str.write(io)
-    io.rewind
-    io.read.should == "abcd\0"
+    @str.to_binary_s.should == "abcd\0"
   end
 end
 
@@ -66,8 +60,7 @@ describe BinData::Stringz, "when reading" do
   end
 
   it "should fail if no zero byte is found" do
-    io = StringIO.new("abcd")
-    lambda {@str.read(io) }.should raise_error(EOFError)
+    lambda {@str.read("abcd") }.should raise_error(EOFError)
   end
 end
 
@@ -141,19 +134,18 @@ describe BinData::Stringz, "with max_length" do
     @str.value.should == "abcd"
   end
 
+  it "should write values greater than max_length" do
+    @str.value = "abcde"
+    @str.to_binary_s.should == "abcd\0"
+  end
+
   it "should write values less than max_length" do
-    io = StringIO.new
     @str.value = "abc"
-    @str.write(io)
-    io.rewind
-    io.read.should == "abc\0"
+    @str.to_binary_s.should == "abc\0"
   end
 
   it "should write values exactly max_length" do
-    io = StringIO.new
     @str.value = "abcd"
-    @str.write(io)
-    io.rewind
-    io.read.should == "abcd\0"
+    @str.to_binary_s.should == "abcd\0"
   end
 end

data/spec/struct_spec.rb

@@ -3,36 +3,7 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata'
 
-describe BinData::Struct, "with hidden fields" do
-  before(:each) do
-    @params = { :hide => [:b, 'c'],
-                :fields => [
-                   [:int8, :a],
-                   [:int8, 'b', {:initial_value => 10}],
-                   [:int8, :c],
-                   [:int8, :d, {:value => :b}]] }
-    @obj = BinData::Struct.new(@params)
-  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::Struct do
+describe BinData::Struct, "when initializing" do
   it "should fail on non registered types" do
     params = {:fields => [[:non_registered_type, :a]]}
     lambda {
@@ -56,7 +27,6 @@ describe BinData::Struct do
   end
 
   it "should fail when field name shadows an existing method" do
-    # note that #invert is from Hash.instance_methods
     params = {:fields => [[:int8, :object_id]]}
     lambda {
       BinData::Struct.new(params)
@@ -71,6 +41,35 @@ describe BinData::Struct do
   end
 end
 
+describe BinData::Struct, "with hidden fields" do
+  before(:each) do
+    @params = { :hide => [:b, 'c'],
+                :fields => [
+                   [:int8, :a],
+                   [:int8, 'b', {:initial_value => 10}],
+                   [:int8, :c],
+                   [:int8, :d, {:value => :b}]] }
+    @obj = BinData::Struct.new(@params)
+  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::Struct, "with multiple fields" do
   before(:each) do
     @params = { :fields => [ [:int8, :a], [:int8, :b] ] }
@@ -86,9 +85,9 @@ describe BinData::Struct, "with multiple fields" do
   end
 
   it "should identify accepted parameters" do
-    BinData::Struct.internal_parameters.should include(:fields)
-    BinData::Struct.internal_parameters.should include(:hide)
-    BinData::Struct.internal_parameters.should include(:endian)
+    BinData::Struct.accepted_internal_parameters.should include(:fields)
+    BinData::Struct.accepted_internal_parameters.should include(:hide)
+    BinData::Struct.accepted_internal_parameters.should include(:endian)
   end
 
   it "should return field names" do
@@ -98,28 +97,23 @@ describe BinData::Struct, "with multiple fields" do
   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
@@ -132,10 +126,38 @@ describe BinData::Struct, "with multiple fields" do
     snap.should == { "a" => 1, "b" => 2 }
   end
 
-  it "should return field_names" do
-    @obj.field_names.should == ["a", "b"]
+  it "should assign from partial hash" do
+    @obj.assign("a" => 3)
+    @obj.a.should == 3
+    @obj.b.should == 0
+  end
+
+  it "should assign from hash" do
+    @obj.assign("a" => 3, "b" => 4)
+    @obj.a.should == 3
+    @obj.b.should == 4
+  end
+
+  it "should assign from Struct" do
+    src = BinData::Struct.new(@params)
+    src.a = 3
+    src.b = 4
+
+    @obj.assign(src)
+    @obj.a.should == 3
+    @obj.b.should == 4
+  end
+
+  it "should assign from snapshot" do
+    src = BinData::Struct.new(@params)
+    src.a = 3
+    src.b = 4
+
+    @obj.assign(src.snapshot)
+    @obj.a.should == 3
+    @obj.b.should == 4
   end
-  
+
   it "should fail on unknown method call" do
     lambda { @obj.does_not_exist }.should raise_error(NoMethodError)
   end
@@ -174,11 +196,11 @@ describe BinData::Struct, "with nested structs" do
     @obj.c.z.should == 0
   end
 
-  it "should return correct offset of" do
-    @obj.offset_of("b").should == 1
-    @obj.offset_of("b").should == 1
-    @obj.offset_of("c").should == 3
-    @obj.offset_of("y").should be_nil
+  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
 
@@ -215,35 +237,42 @@ describe BinData::Struct, "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::Struct, "with bit fields" do
   before(:each) do
-    @params = { :fields => [ [:bit1le, :a], [:bit2le, :b] ] }
+    @params = { :fields => [ [:bit1le, :a], [:bit2le, :b], [:uint8, :c], [:bit1le, :d] ] }
     @obj = BinData::Struct.new(@params)
     @obj.a = 1
     @obj.b = 2
+    @obj.c = 3
+    @obj.d = 1
   end
 
   it "should return num_bytes" do
-    @obj.num_bytes.should == 1
+    @obj.num_bytes.should == 3
   end
 
   it "should write" do
-    @obj.to_s.should == [0b0000_0101].pack("C")
+    @obj.to_binary_s.should == [0b0000_0101, 3, 1].pack("C*")
   end
 
   it "should read" do
-    str = [0b0000_0110].pack("C")
+    str = [0b0000_0110, 5, 0].pack("C*")
     @obj.read(str)
     @obj.a.should == 0
     @obj.b.should == 3
+    @obj.c.should == 5
+    @obj.d.should == 0
+  end
+
+  it "should have correct offsets" do
+    @obj.a.offset.should == 0
+    @obj.b.offset.should == 0
+    @obj.c.offset.should == 1
+    @obj.d.offset.should == 2
   end
 end
 
@@ -256,8 +285,7 @@ describe BinData::Struct, "with nested endian" do
                            [:struct, :s, nested_params],
                            [:int16, :d]] }
     obj = BinData::Struct.new(params)
-    str = "\x00\x01\x02\x00\x03\x00\x00\x04"
-    obj.read(str)
+    obj.read("\x00\x01\x02\x00\x03\x00\x00\x04")
 
     obj.a.should   == 1
     obj.s.b.should == 2