bindata 1.8.3 → 2.0.0

data/test/common.rb

@@ -49,11 +49,7 @@ class ExampleSingle < BinData::BasePrimitive
 end
 
 def binary(str)
-  if str.respond_to?(:force_encoding)
-    str.dup.force_encoding(Encoding::BINARY)
-  else
-    str
-  end
+  str.dup.force_encoding(Encoding::BINARY)
 end
 
 module Kernel

data/test/io_test.rb

@@ -152,21 +152,6 @@ describe BinData::IO::Write, "when writing" do
     stream.value.must_equal "abcd"
   end
 
-  it "has #offset" do
-    io.offset.must_equal 0
-
-    io.writebytes("abcd")
-    io.offset.must_equal 4
-
-    io.writebytes("ABCD")
-    io.offset.must_equal 8
-  end
-
-  it "rounds up #offset when writing bits" do
-    io.writebits(123, 9, :little)
-    io.offset.must_equal 2
-  end
-
   it "flushes" do
     io.writebytes("abcd")
     io.flush

data/test/lazy_test.rb

@@ -73,16 +73,12 @@ end
 
 describe BinData::LazyEvaluator, "with one parent" do
   subject {
-    parent_methods = {:m1 => 'Pm1', :m2 => 'Pm2', :com1 => 'PmC', :mm => 3}
+    parent_methods = {:m1 => 'Pm1', :com1 => 'PmC', :mm => 3}
     parent_params  = {:p1 => 'Pp1', :com1 => 'PpC'}
     parent_obj = MockBinDataObject.new(parent_methods, parent_params)
 
-    class << parent_obj
-      def echo(a1, a2)
-        [a1, a2]
-      end
-
-      private :m2
+    def parent_obj.echo(a1, a2)
+      [a1, a2]
     end
 
     methods = {:m1 => 'm1', :com1 => 'mC'}
@@ -122,10 +118,6 @@ describe BinData::LazyEvaluator, "with one parent" do
     lazy_eval(lambda { echo(p1, m1) }).must_equal ['Pp1', 'Pm1']
   end
 
-  it "invokes private methods in the parent" do
-    lazy_eval(lambda { m2 }).must_equal 'Pm2'
-  end
-
   it "resolves parameters in preference to methods in the parent" do
     lazy_eval(lambda { com1 }).must_equal 'PpC'
   end

data/test/record_test.rb

@@ -105,12 +105,12 @@ describe BinData::Record, "with anonymous fields" do
   let(:obj) { AnonymousRecord.new }
 
   it "only shows non anonymous fields" do
-    obj.field_names.must_equal ["a"]
+    obj.field_names.must_equal [:a]
   end
 
   it "does not include anonymous fields in snapshot" do
     obj.a = 5
-    obj.snapshot.must_equal({"a" => 5})
+    obj.snapshot.must_equal({:a => 5})
   end
 
   it "writes anonymous fields" do
@@ -133,7 +133,7 @@ describe BinData::Record, "with hidden fields" do
   let(:obj) { HiddenRecord.new }
 
   it "only shows fields that aren't hidden" do
-    obj.field_names.must_equal ["a", "d"]
+    obj.field_names.must_equal [:a, :d]
   end
 
   it "accesses hidden fields directly" do
@@ -146,7 +146,7 @@ describe BinData::Record, "with hidden fields" do
 
   it "does not include hidden fields in snapshot" do
     obj.b = 5
-    obj.snapshot.must_equal({"a" => 0, "d" => 5})
+    obj.snapshot.must_equal({:a => 0, :d => 5})
   end
 end
 
@@ -198,11 +198,11 @@ describe BinData::Record, "with multiple fields" do
     snap = obj.snapshot
     snap.a.must_equal 1
     snap.b.must_equal 2
-    snap.must_equal({ "a" => 1, "b" => 2 })
+    snap.must_equal({ :a => 1, :b => 2 })
   end
 
   it "returns field_names" do
-    obj.field_names.must_equal ["a", "b"]
+    obj.field_names.must_equal [:a, :b]
   end
   
   it "fails on unknown method call" do
@@ -227,11 +227,11 @@ describe BinData::Record, "with nested structs" do
   let(:obj) { NestedStructRecord.new }
 
   it "includes nested field names" do
-    obj.field_names.must_equal ["a", "b", "c"]
+    obj.field_names.must_equal [:a, :b, :c]
   end
 
   it "hides nested field names" do
-    obj.b.field_names.must_equal ["x"]
+    obj.b.field_names.must_equal [:x]
   end
 
   it "accesses nested fields" do
@@ -241,12 +241,12 @@ describe BinData::Record, "with nested structs" do
     obj.c.y.must_equal 3
   end
 
-  it "returns correct abs_offset" do
-    obj.abs_offset.must_equal 0
-    obj.b.abs_offset.must_equal 1
-    obj.b.w.abs_offset.must_equal 1
-    obj.c.abs_offset.must_equal 3
-    obj.c.z.abs_offset.must_equal 4
+  it "returns correct offset" do
+    obj.offset.must_equal 0
+    obj.b.offset.must_equal 1
+    obj.b.w.offset.must_equal 1
+    obj.c.offset.must_equal 3
+    obj.c.z.offset.must_equal 4
   end
 
   it "returns correct rel_offset" do
@@ -276,7 +276,7 @@ describe BinData::Record, "with nested array of primitives" do
   let(:obj) { NestedPrimitiveArrayRecord.new }
 
   it "uses block as :type" do
-    obj.snapshot.must_equal({"a" => [0, 1, 2]})
+    obj.snapshot.must_equal({:a => [0, 1, 2]})
   end
 end
 
@@ -292,7 +292,7 @@ describe BinData::Record, "with nested array of structs" do
 
   it "uses block as struct for :type" do
     obj.a[0].b = 2
-    obj.snapshot.must_equal({"a" => [{"b" => 2, "c" => 0}]})
+    obj.snapshot.must_equal({:a => [{:b => 2, :c => 0}]})
   end
 end
 
@@ -472,19 +472,13 @@ describe BinData::Record, "with :onlyif" do
 
   it "initial state" do
     obj.num_bytes.must_equal 2
-    obj.snapshot.must_equal({"a" => 3, "b" => 5})
+    obj.snapshot.must_equal({:a => 3, :b => 5})
     obj.to_binary_s.must_equal "\x03\x05"
   end
 
-  it "identifies if fields are included" do
-    obj.a?.must_equal true
-    obj.b?.must_equal true
-    obj.c?.must_equal false
-  end
-
   it "reads as lambdaed" do
     obj.read("\x01\x02")
-    obj.snapshot.must_equal({"a" => 1, "c" => 2})
+    obj.snapshot.must_equal({:a => 1, :c => 2})
   end
 end
 
@@ -502,14 +496,14 @@ describe BinData::Record, "derived classes" do
   end
 
   it "does not affect parent" do
-    ParentRecord.new.field_names.must_equal ["a"]
+    ParentRecord.new.field_names.must_equal [:a]
   end
 
   it "inherits fields for first child" do
-    Child1Record.new.field_names.must_equal ["a", "b"]
+    Child1Record.new.field_names.must_equal [:a, :b]
   end
 
   it "inherits fields for second child" do
-    Child2Record.new.field_names.must_equal ["a", "b", "c"]
+    Child2Record.new.field_names.must_equal [:a, :b, :c]
   end
 end

data/test/string_test.rb

@@ -260,40 +260,38 @@ describe BinData::String, "with :pad_front" do
 end
 
 describe BinData::String, "with Ruby 1.9 encodings" do
-  if RUBY_VERSION >= "1.9"
-    class UTF8String < BinData::String
-      def snapshot
-        super.force_encoding('UTF-8')
-      end
+  class UTF8String < BinData::String
+    def snapshot
+      super.force_encoding('UTF-8')
     end
+  end
 
-    let(:obj) { UTF8String.new }
-    let(:binary_str) { binary("\xC3\x85\xC3\x84\xC3\x96") }
-    let(:utf8_str) { binary_str.dup.force_encoding('UTF-8') }
+  let(:obj) { UTF8String.new }
+  let(:binary_str) { binary("\xC3\x85\xC3\x84\xC3\x96") }
+  let(:utf8_str) { binary_str.dup.force_encoding('UTF-8') }
 
-    it "stores assigned values as binary" do
-      obj.assign(utf8_str)
-      obj.to_binary_s.must_equal binary_str
-    end
+  it "stores assigned values as binary" do
+    obj.assign(utf8_str)
+    obj.to_binary_s.must_equal binary_str
+  end
 
-    it "stores read values as binary" do
-      obj = UTF8String.new(:read_length => binary_str.length)
-      obj.read(binary_str)
+  it "stores read values as binary" do
+    obj = UTF8String.new(:read_length => binary_str.length)
+    obj.read(binary_str)
 
-      obj.to_binary_s.must_equal binary_str
-    end
+    obj.to_binary_s.must_equal binary_str
+  end
 
-    it "returns values in correct encoding" do
-      obj.assign(utf8_str)
+  it "returns values in correct encoding" do
+    obj.assign(utf8_str)
 
-      obj.snapshot.must_equal utf8_str
-    end
+    obj.snapshot.must_equal utf8_str
+  end
 
-    it "has correct num_bytes" do
-      obj.assign(utf8_str)
+  it "has correct num_bytes" do
+    obj.assign(utf8_str)
 
-      obj.num_bytes.must_equal binary_str.length
-    end
+    obj.num_bytes.must_equal binary_str.length
   end
 end
 

data/test/struct_test.rb

@@ -51,12 +51,12 @@ describe BinData::Struct, "with anonymous fields" do
   }
 
   it "only shows non anonymous fields" do
-    obj.field_names.must_equal ["a"]
+    obj.field_names.must_equal [:a]
   end
 
   it "does not include anonymous fields in snapshot" do
     obj.a = 5
-    obj.snapshot.must_equal({"a" => 5})
+    obj.snapshot.must_equal({:a => 5})
   end
 
   it "writes anonymous fields" do
@@ -78,7 +78,7 @@ describe BinData::Struct, "with hidden fields" do
   }
 
   it "only shows fields that aren't hidden" do
-    obj.field_names.must_equal ["a", "d"]
+    obj.field_names.must_equal [:a, :d]
   end
 
   it "accesses hidden fields directly" do
@@ -91,7 +91,7 @@ describe BinData::Struct, "with hidden fields" do
 
   it "does not include hidden fields in snapshot" do
     obj.b = 7
-    obj.snapshot.must_equal({"a" => 0, "d" => 7})
+    obj.snapshot.must_equal({:a => 0, :d => 7})
   end
 
   it "detects hidden fields with has_key?" do
@@ -103,7 +103,7 @@ describe BinData::Struct, "with multiple fields" do
   let(:params) { { :fields => [ [:int8, :a], [:int8, :b] ] } }
   let(:obj) { BinData::Struct.new({:a => 1, :b => 2}, params) }
 
-  specify { obj.field_names.must_equal ["a", "b"] }
+  specify { obj.field_names.must_equal [:a, :b] }
   specify { obj.to_binary_s.must_equal "\x01\x02" }
 
   it "returns num_bytes" do
@@ -156,17 +156,17 @@ describe BinData::Struct, "with multiple fields" do
     snap = obj.snapshot
     snap.a.must_equal 1
     snap.b.must_equal 2
-    snap.must_equal({ "a" => 1, "b" => 2 })
+    snap.must_equal({ :a => 1, :b => 2 })
   end
 
   it "assigns from partial hash" do
-    obj.assign("a" => 3)
+    obj.assign(:a => 3)
     obj.a.must_equal 3
     obj.b.must_equal 0
   end
 
   it "assigns from hash" do
-    obj.assign("a" => 3, "b" => 4)
+    obj.assign(:a => 3, :b => 4)
     obj.a.must_equal 3
     obj.b.must_equal 4
   end
@@ -202,19 +202,19 @@ describe BinData::Struct, "with multiple fields" do
 
   describe "#snapshot" do
     it "has ordered #keys" do
-      obj.snapshot.keys.must_equal ["a", "b"]
+      obj.snapshot.keys.must_equal [:a, :b]
     end
 
     it "has ordered #each" do
       keys = []
       obj.snapshot.each { |el| keys << el[0] }
-      keys.must_equal ["a", "b"]
+      keys.must_equal [:a, :b]
     end
 
     it "has ordered #each_pair" do
       keys = []
       obj.snapshot.each_pair { |k, v| keys << k }
-      keys.must_equal ["a", "b"]
+      keys.must_equal [:a, :b]
     end
   end
 end
@@ -234,7 +234,7 @@ describe BinData::Struct, "with nested structs" do
     BinData::Struct.new(params)
   }
 
-  specify { obj.field_names.must_equal ["a", "b", "c"] }
+  specify { obj.field_names.must_equal [:a, :b, :c] }
 
   it "returns num_bytes" do
     obj.b.num_bytes.must_equal 2
@@ -250,11 +250,11 @@ describe BinData::Struct, "with nested structs" do
     obj.c.z.must_equal 0
   end
 
-  it "returns correct abs_offset" do
-    obj.b.abs_offset.must_equal 1
-    obj.b.w.abs_offset.must_equal 1
-    obj.c.abs_offset.must_equal 3
-    obj.c.z.abs_offset.must_equal 4
+  it "returns correct offset" do
+    obj.b.offset.must_equal 1
+    obj.b.w.offset.must_equal 1
+    obj.c.offset.must_equal 3
+    obj.c.z.offset.must_equal 4
   end
 end
 
@@ -313,10 +313,10 @@ describe BinData::Struct, "with bit fields" do
   end
 
   it "has correct offsets" do
-    obj.a.rel_offset.must_equal 0
-    obj.b.rel_offset.must_equal 0
-    obj.c.rel_offset.must_equal 1
-    obj.d.rel_offset.must_equal 2
+    obj.a.offset.must_equal 0
+    obj.b.offset.must_equal 0
+    obj.c.offset.must_equal 1
+    obj.d.offset.must_equal 2
   end
 end
 
@@ -338,37 +338,6 @@ describe BinData::Struct, "with nested endian" do
   end
 end
 
-describe BinData::Struct, "with byte_align" do
-  let(:obj) {
-    params = { :fields => [[:int8, :a],
-                           [:int8, :b, {:byte_align => 5}],
-                           [:bit2, :c],
-                           [:int8, :d, {:byte_align => 3}]] }
-    BinData::Struct.new(params)
-  }
-
-  it "has #num_bytes" do
-    obj.num_bytes.must_equal 10
-  end
-
-  it "reads" do
-    obj.read("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
-    obj.snapshot.must_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 })
-  end
-
-  it "writes" do
-    obj.assign(:a => 1, :b => 2, :c => 3, :d => 4)
-    obj.to_binary_s.must_equal binary("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
-  end
-
-  it "has correct offsets" do
-    obj.a.rel_offset.must_equal 0
-    obj.b.rel_offset.must_equal 5
-    obj.c.rel_offset.must_equal 6
-    obj.d.rel_offset.must_equal 9
-  end
-end
-
 describe BinData::Struct, "with dynamically named types" do
   it "instantiates" do
     dyn = BinData::Struct.new(:name => :my_struct, :fields => [[:int8, :a, {:initial_value => 3}]])

data/test/system_test.rb

@@ -17,7 +17,7 @@ describe "lambdas with index" do
   it "uses index of nearest containing array" do
     arr = BinData::Array.new(:type => :nested_lambda_with_index,
                              :initial_length => 3)
-    arr.snapshot.must_equal [{"a" => 0}, {"a" => 10}, {"a" => 20}]
+    arr.snapshot.must_equal [{:a => 0}, {:a => 10}, {:a => 20}]
   end
 
   it "fails if there is no containing array" do
@@ -93,7 +93,7 @@ describe BinData::Record, "with choice field" do
 
   it "has correct offset" do
     obj = RecordWithNestedChoiceField.new
-    obj.x.b.abs_offset.must_equal 2
+    obj.x.b.offset.must_equal 2
   end
 end
 
@@ -240,17 +240,17 @@ describe "Forward referencing with Primitive" do
   let(:obj) { FRPrimitive.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({"len" => 0, "data" => ""})
+    obj.snapshot.must_equal({:len => 0, :data => ""})
   end
 
   it "reads" do
     obj.read("\x04test")
-    obj.snapshot.must_equal({"len" => 4, "data" => "test"})
+    obj.snapshot.must_equal({:len => 4, :data => "test"})
   end
 
   it "sets value" do
     obj.data = "hello"
-    obj.snapshot.must_equal({"len" => 5, "data" => "hello"})
+    obj.snapshot.must_equal({:len => 5, :data => "hello"})
   end
 end
 
@@ -263,17 +263,17 @@ describe "Forward referencing with Array" do
   let(:obj) { FRArray.new }
 
   it "initialises" do
-    obj.snapshot.must_equal({"len" => 0, "data" => []})
+    obj.snapshot.must_equal({:len => 0, :data => []})
   end
 
   it "reads" do
     obj.read("\x04\x01\x02\x03\x04")
-    obj.snapshot.must_equal({"len" => 4, "data" => [1, 2, 3, 4]})
+    obj.snapshot.must_equal({:len => 4, :data => [1, 2, 3, 4]})
   end
 
   it "sets value" do
     obj.data = [1, 2, 3]
-    obj.snapshot.must_equal({"len" => 3, "data" => [1, 2, 3]})
+    obj.snapshot.must_equal({:len => 3, :data => [1, 2, 3]})
   end
 end
 
@@ -299,7 +299,7 @@ describe BinData::Record, "with custom sized integers" do
 
   it "reads as expected" do
     str = "\x00\x00\x00\x00\x05"
-    CustomIntRecord.read(str).snapshot.must_equal({"a" => 5})
+    CustomIntRecord.read(str).snapshot.must_equal({:a => 5})
   end
 end