bindata 1.2.2 → 1.3.1

data/spec/stringz_spec.rb

@@ -4,148 +4,115 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/stringz'
 
 describe BinData::Stringz, "when empty" do
-  before(:each) do
-    @str = BinData::Stringz.new
-  end
-
-  it "should include the zero byte in num_bytes total" do
-    @str.num_bytes.should == 1
-  end
-
-  it "should not append the zero byte terminator to the value" do
-    @str.value.should == ""
-  end
-
-  it "should write the zero byte terminator" do
-    @str.to_binary_s.should == "\0"
-  end
+  its(:value) { should == "" }
+  its(:num_bytes) { should == 1 }
+  its(:to_binary_s) { should == "\0" }
 end
 
 describe BinData::Stringz, "with value set" do
-  before(:each) do
-    @str = BinData::Stringz.new
-    @str.value = "abcd"
-  end
-
-  it "should include the zero byte in num_bytes total" do
-    @str.num_bytes.should == 5
-  end
+  subject { BinData::Stringz.new("abcd") }
 
-  it "should not append the zero byte terminator to the value" do
-    @str.value.should == "abcd"
-  end
-
-  it "should write the zero byte terminator" do
-    @str.to_binary_s.should == "abcd\0"
-  end
+  its(:value) { should == "abcd" }
+  its(:num_bytes) { should == 5 }
+  its(:to_binary_s) { should == "abcd\0" }
 end
 
 describe BinData::Stringz, "when reading" do
-  before(:each) do
-    @str = BinData::Stringz.new
-  end
-
   it "should stop at the first zero byte" do
     io = StringIO.new("abcd\0xyz\0")
-    @str.read(io)
-    @str.value.should == "abcd"
+    subject.read(io)
     io.pos.should == 5
+    subject.should == "abcd"
   end
 
   it "should handle a zero length string" do
     io = StringIO.new("\0abcd")
-    @str.read(io)
-    @str.value.should == ""
+    subject.read(io)
     io.pos.should == 1
+    subject.should == ""
   end
 
   it "should fail if no zero byte is found" do
-    lambda {@str.read("abcd") }.should raise_error(EOFError)
+    lambda {subject.read("abcd") }.should raise_error(EOFError)
   end
 end
 
 describe BinData::Stringz, "when setting the value" do
-  before(:each) do
-    @str = BinData::Stringz.new
-  end
-
   it "should include the zero byte in num_bytes total" do
-    @str.value = "abcd"
-    @str.num_bytes.should == 5
+    subject.assign("abcd")
+    subject.num_bytes.should == 5
   end
 
   it "should accept empty strings" do
-    @str.value = ""
-    @str.value.should == ""
+    subject.assign("")
+    subject.should == ""
   end
 
   it "should accept strings that aren't zero terminated" do
-    @str.value = "abcd"
-    @str.value.should == "abcd"
+    subject.assign("abcd")
+    subject.should == "abcd"
   end
 
   it "should accept strings that are zero terminated" do
-    @str.value = "abcd\0"
-    @str.value.should == "abcd"
+    subject.assign("abcd\0")
+    subject.should == "abcd"
   end
 
   it "should accept up to the first zero byte" do
-    @str.value = "abcd\0xyz\0"
-    @str.value.should == "abcd"
+    subject.assign("abcd\0xyz\0")
+    subject.should == "abcd"
   end
 end
 
 describe BinData::Stringz, "with max_length" do
-  before(:each) do
-    @str = BinData::Stringz.new(:max_length => 5)
-  end
+  subject { BinData::Stringz.new(:max_length => 5) }
 
   it "should read less than max_length" do
     io = StringIO.new("abc\0xyz")
-    @str.read(io)
-    @str.value.should == "abc"
+    subject.read(io)
+    subject.should == "abc"
   end
 
   it "should read exactly max_length" do
     io = StringIO.new("abcd\0xyz")
-    @str.read(io)
-    @str.value.should == "abcd"
+    subject.read(io)
+    subject.should == "abcd"
   end
 
   it "should read no more than max_length" do
     io = StringIO.new("abcdefg\0xyz")
-    @str.read(io)
-    @str.value.should == "abcd"
+    subject.read(io)
     io.pos.should == 5
+    subject.should == "abcd"
   end
 
   it "should accept values less than max_length" do
-    @str.value = "abc"
-    @str.value.should == "abc"
+    subject.assign("abc")
+    subject.should == "abc"
   end
 
   it "should accept values exactly max_length" do
-    @str.value = "abcd"
-    @str.value.should == "abcd"
+    subject.assign("abcd")
+    subject.should == "abcd"
   end
 
   it "should trim values greater than max_length" do
-    @str.value = "abcde"
-    @str.value.should == "abcd"
+    subject.assign("abcde")
+    subject.should == "abcd"
   end
 
   it "should write values greater than max_length" do
-    @str.value = "abcde"
-    @str.to_binary_s.should == "abcd\0"
+    subject.assign("abcde")
+    subject.to_binary_s.should == "abcd\0"
   end
 
   it "should write values less than max_length" do
-    @str.value = "abc"
-    @str.to_binary_s.should == "abc\0"
+    subject.assign("abc")
+    subject.to_binary_s.should == "abc\0"
   end
 
   it "should write values exactly max_length" do
-    @str.value = "abcd"
-    @str.to_binary_s.should == "abcd\0"
+    subject.assign("abcd")
+    subject.to_binary_s.should == "abcd\0"
   end
 end

data/spec/struct_spec.rb

@@ -42,72 +42,71 @@ describe BinData::Struct, "when initializing" do
 end
 
 describe BinData::Struct, "with anonymous fields" do
-  before(:each) do
-    @params = { :fields => [
-                   [:int8, :a, {:initial_value => 10}],
-                   [:int8, nil],
-                   [:int8, '', {:value => :a}]] }
-    @obj = BinData::Struct.new(@params)
-  end
+  subject {
+    params = { :fields => [
+                            [:int8, :a, {:initial_value => 5}],
+                            [:int8, nil],
+                            [:int8, '', {:value => :a}]
+                          ] }
+    BinData::Struct.new(params)
+  }
 
   it "should only show non anonymous fields" do
-    @obj.field_names.should == ["a"]
+    subject.field_names.should == ["a"]
   end
 
   it "should not include anonymous fields in snapshot" do
-    @obj.a = 5
-    @obj.snapshot.should == {"a" => 5}
+    subject.a = 5
+    subject.snapshot.should == {"a" => 5}
   end
 
   it "should write anonymous fields" do
-    str = "\001\002\003"
-    @obj.read(str)
-    @obj.a.clear
-    @obj.to_binary_s.should == "\012\002\012"
+    subject.read("\001\002\003")
+    subject.a.clear
+    subject.to_binary_s.should == "\005\002\005"
   end
 end
 
 describe BinData::Struct, "with hidden fields" do
-  before(:each) do
-    @params = { :hide => [:b, 'c'],
-                :fields => [
+  subject {
+    params = { :hide => [:b, :c],
+               :fields => [
                    [:int8, :a],
-                   [:int8, 'b', {:initial_value => 10}],
+                   [:int8, 'b', {:initial_value => 5}],
                    [:int8, :c],
                    [:int8, :d, {:value => :b}]] }
-    @obj = BinData::Struct.new(@params)
-  end
+    BinData::Struct.new(params)
+  }
 
   it "should only show fields that aren't hidden" do
-    @obj.field_names.should == ["a", "d"]
+    subject.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
+    subject.b.should == 5
+    subject.c = 15
+    subject.c.should == 15
 
-    @obj.should respond_to(:b=)
+    subject.should respond_to(:b=)
   end
 
   it "should not include hidden fields in snapshot" do
-    @obj.b = 5
-    @obj.snapshot.should == {"a" => 0, "d" => 5}
+    subject.b = 7
+    subject.snapshot.should == {"a" => 0, "d" => 7}
   end
 end
 
 describe BinData::Struct, "with multiple fields" do
-  before(:each) do
-    @params = { :fields => [ [:int8, :a], [:int8, :b] ] }
-    @obj = BinData::Struct.new(@params)
-    @obj.a = 1
-    @obj.b = 2
-  end
+  let(:params) { { :fields => [ [:int8, :a], [:int8, :b] ] } }
+  subject { BinData::Struct.new({:a => 1, :b => 2}, params) }
+
+  its(:field_names) { should == ["a", "b"] }
+  its(:to_binary_s) { should == "\x01\x02" }
 
   it "should return num_bytes" do
-    @obj.a.num_bytes.should == 1
-    @obj.b.num_bytes.should == 1
-    @obj.num_bytes.should   == 2
+    subject.a.num_bytes.should == 1
+    subject.b.num_bytes.should == 1
+    subject.num_bytes.should   == 2
   end
 
   it "should identify accepted parameters" do
@@ -116,194 +115,174 @@ describe BinData::Struct, "with multiple fields" do
     BinData::Struct.accepted_parameters.all.should include(:endian)
   end
 
-  it "should return field names" do
-    @obj.field_names.should == ["a", "b"]
-  end
-
   it "should clear" do
-    @obj.a = 6
-    @obj.clear
-    @obj.should be_clear
+    subject.a = 6
+    subject.clear
+    subject.should be_clear
   end
 
   it "should clear individual elements" do
-    @obj.a = 6
-    @obj.b = 7
-    @obj.a.clear
-    @obj.a.should be_clear
-    @obj.b.should_not be_clear
-  end
-
-  it "should write ordered" do
-    @obj.to_binary_s.should == "\x01\x02"
+    subject.a = 6
+    subject.b = 7
+    subject.a.clear
+    subject.a.should be_clear
+    subject.b.should_not be_clear
   end
 
   it "should read ordered" do
-    @obj.read("\x03\x04")
+    subject.read("\x03\x04")
 
-    @obj.a.should == 3
-    @obj.b.should == 4
+    subject.a.should == 3
+    subject.b.should == 4
   end
 
   it "should return a snapshot" do
-    snap = @obj.snapshot
+    snap = subject.snapshot
     snap.a.should == 1
     snap.b.should == 2
     snap.should == { "a" => 1, "b" => 2 }
   end
 
   it "should assign from partial hash" do
-    @obj.assign("a" => 3)
-    @obj.a.should == 3
-    @obj.b.should == 0
+    subject.assign("a" => 3)
+    subject.a.should == 3
+    subject.b.should == 0
   end
 
   it "should assign from hash" do
-    @obj.assign("a" => 3, "b" => 4)
-    @obj.a.should == 3
-    @obj.b.should == 4
+    subject.assign("a" => 3, "b" => 4)
+    subject.a.should == 3
+    subject.b.should == 4
   end
 
   it "should assign from nil" do
-    @obj.assign(nil)
-    @obj.should be_clear
+    subject.assign(nil)
+    subject.should be_clear
   end
 
   it "should assign from Struct" do
-    src = BinData::Struct.new(@params)
+    src = BinData::Struct.new(params)
     src.a = 3
     src.b = 4
 
-    @obj.assign(src)
-    @obj.a.should == 3
-    @obj.b.should == 4
+    subject.assign(src)
+    subject.a.should == 3
+    subject.b.should == 4
   end
 
   it "should assign from snapshot" do
-    src = BinData::Struct.new(@params)
+    src = BinData::Struct.new(params)
     src.a = 3
     src.b = 4
 
-    @obj.assign(src.snapshot)
-    @obj.a.should == 3
-    @obj.b.should == 4
+    subject.assign(src.snapshot)
+    subject.a.should == 3
+    subject.b.should == 4
   end
 
   it "should fail on unknown method call" do
-    lambda { @obj.does_not_exist }.should raise_error(NoMethodError)
+    lambda { subject.does_not_exist }.should raise_error(NoMethodError)
   end
 end
 
 describe BinData::Struct, "with nested structs" do
-  before(:each) do
+  subject {
     inner1 = [ [:int8, :w, {:initial_value => 3}],
                [:int8, :x, {:value => :the_val}] ]
 
     inner2 = [ [:int8, :y, {:value => lambda { parent.b.w }}],
                [:int8, :z] ]
 
-    @params = { :fields => [
-                  [:int8, :a, {:initial_value => 6}],
-                  [:struct, :b, {:fields => inner1, :the_val => :a}],
-                  [:struct, :c, {:fields => inner2}]] }
-    @obj = BinData::Struct.new(@params)
-  end
+    params = { :fields => [
+                 [:int8, :a, {:initial_value => 6}],
+                 [:struct, :b, {:fields => inner1, :the_val => :a}],
+                 [:struct, :c, {:fields => inner2}]] }
+    BinData::Struct.new(params)
+  }
 
-  it "should included nested field names" do
-    @obj.field_names.should == ["a", "b", "c"]
-  end
+  its(:field_names) { should == ["a", "b", "c"] }
 
   it "should return num_bytes" do
-    @obj.b.num_bytes.should == 2
-    @obj.c.num_bytes.should == 2
-    @obj.num_bytes.should == 5
+    subject.b.num_bytes.should == 2
+    subject.c.num_bytes.should == 2
+    subject.num_bytes.should == 5
   end
 
   it "should access nested fields" do
-    @obj.a.should   == 6
-    @obj.b.w.should == 3
-    @obj.b.x.should == 6
-    @obj.c.y.should == 3
-    @obj.c.z.should == 0
+    subject.a.should   == 6
+    subject.b.w.should == 3
+    subject.b.x.should == 6
+    subject.c.y.should == 3
+    subject.c.z.should == 0
   end
 
   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
+    subject.b.offset.should == 1
+    subject.b.w.offset.should == 1
+    subject.c.offset.should == 3
+    subject.c.z.offset.should == 4
   end
 end
 
 describe BinData::Struct, "with an endian defined" do
-  before(:each) do
-    @obj = BinData::Struct.new(:endian => :little,
-                               :fields => [
-                                 [:uint16, :a],
-                                 [:float, :b],
-                                 [:array, :c,
-                                   {:type => :int8, :initial_length => 2}],
-                                 [:choice, :d,
-                                   {:choices => [[:uint16], [:uint32]],
-                                    :selection => 1}],
-                                 [:struct, :e,
-                                   {:fields => [[:uint16, :f],
-                                                [:uint32be, :g]]}],
-                                 [:struct, :h,
-                                   {:fields => [
-                                     [:struct, :i,
-                                       {:fields => [[:uint16, :j]]}]]}]])
-
-  end
+  subject {
+    BinData::Struct.new(:endian => :little,
+                        :fields => [
+                                     [:uint16, :a],
+                                     [:float, :b],
+                                     [:array, :c,
+                                       {:type => :int8, :initial_length => 2}],
+                                     [:choice, :d,
+                                       {:choices => [[:uint16], [:uint32]],
+                                        :selection => 1}],
+                                     [:struct, :e,
+                                       {:fields => [[:uint16, :f],
+                                                    [:uint32be, :g]]}],
+                                     [:struct, :h,
+                                       {:fields => [
+                                         [:struct, :i,
+                                           {:fields => [[:uint16, :j]]}]]}]])
+  }
 
   it "should use correct endian" do
-    @obj.a = 1
-    @obj.b = 2.0
-    @obj.c[0] = 3
-    @obj.c[1] = 4
-    @obj.d = 5
-    @obj.e.f = 6
-    @obj.e.g = 7
-    @obj.h.i.j = 8
+    subject.a = 1
+    subject.b = 2.0
+    subject.c[0] = 3
+    subject.c[1] = 4
+    subject.d = 5
+    subject.e.f = 6
+    subject.e.g = 7
+    subject.h.i.j = 8
 
     expected = [1, 2.0, 3, 4, 5, 6, 7, 8].pack('veCCVvNv')
 
-    @obj.to_binary_s.should == expected
+    subject.to_binary_s.should == expected
   end
 end
 
 describe BinData::Struct, "with bit fields" do
-  before(:each) do
-    @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
+  subject {
+    params = { :fields => [ [:bit1le, :a], [:bit2le, :b], [:uint8, :c], [:bit1le, :d] ] }
+    BinData::Struct.new({:a => 1, :b => 2, :c => 3, :d => 1}, params)
+  }
 
-  it "should return num_bytes" do
-    @obj.num_bytes.should == 3
-  end
-
-  it "should write" do
-    @obj.to_binary_s.should == [0b0000_0101, 3, 1].pack("C*")
-  end
+  its(:num_bytes) { should == 3 }
+  its(:to_binary_s) { should == [0b0000_0101, 3, 1].pack("C*") }
 
   it "should read" do
     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
+    subject.read(str)
+    subject.a.should == 0
+    subject.b.should == 3
+    subject.c.should == 5
+    subject.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
+    subject.a.offset.should == 0
+    subject.b.offset.should == 0
+    subject.c.offset.should == 1
+    subject.d.offset.should == 2
   end
 end
 
@@ -315,12 +294,12 @@ describe BinData::Struct, "with nested endian" do
                :fields => [[:int16, :a],
                            [:struct, :s, nested_params],
                            [:int16, :d]] }
-    obj = BinData::Struct.new(params)
-    obj.read("\x00\x01\x02\x00\x03\x00\x00\x04")
+    subject = BinData::Struct.new(params)
+    subject.read("\x00\x01\x02\x00\x03\x00\x00\x04")
 
-    obj.a.should   == 1
-    obj.s.b.should == 2
-    obj.s.c.should == 3
-    obj.d.should   == 4
+    subject.a.should   == 1
+    subject.s.b.should == 2
+    subject.s.c.should == 3
+    subject.d.should   == 4
   end
 end