bindata 0.8.1 → 0.9.0

data/spec/string_spec.rb

@@ -3,7 +3,7 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/string'
 
-describe "Test mutual exclusion of parameters" do
+describe BinData::String, "with mutually exclusive parameters" do
   it ":value and :initial_value" do
     params = {:value => "", :initial_value => ""}
     lambda { BinData::String.new(params) }.should raise_error(ArgumentError)
@@ -20,170 +20,170 @@ describe "Test mutual exclusion of parameters" do
   end
 end
 
-describe "A String with deprecated parameters" do
+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)
-    obj.value.should eql("abc")
+    obj.value.should == "abc"
   end
 end
 
-describe "A String with :read_length" do
+describe BinData::String, "with :read_length" do
   before(:each) do
     @str = BinData::String.new(:read_length => 5)
   end
 
   it "should have default value" do
-    @str.num_bytes.should eql(0)
-    @str.value.should eql("")
+    @str.num_bytes.should == 0
+    @str.value.should == ""
   end
 
   it "should read :read_length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
-    @str.value.should eql("abcde")
+    @str.value.should == "abcde"
   end
 
   it "should remember :read_length after value is cleared" do
     @str.value = "abc"
-    @str.num_bytes.should eql(3)
+    @str.num_bytes.should == 3
     @str.clear
     io = StringIO.new("abcdefghij")
     @str.read(io)
-    @str.value.should eql("abcde")
+    @str.value.should == "abcde"
   end
 end
 
-describe "A String with :length" do
+describe BinData::String, "with :length" do
   before(:each) do
     @str = BinData::String.new(:length => 5)
   end
 
   it "should set num_bytes" do
-    @str.num_bytes.should eql(5)
+    @str.num_bytes.should == 5
   end
 
   it "should fill value with pad_char" do
-    @str.value.should eql("\0\0\0\0\0")
+    @str.value.should == "\0\0\0\0\0"
   end
 
   it "should retain :length after value is set" do
     @str.value = "abcdefghij"
-    @str.num_bytes.should eql(5)
+    @str.num_bytes.should == 5
   end
 
   it "should read :length bytes" do
     io = StringIO.new("abcdefghij")
     @str.read(io)
-    @str.value.should eql("abcde")
+    @str.value.should == "abcde"
   end
 
   it "should pad values less than :length" do
     @str.value = "abc"
-    @str.value.should eql("abc\0\0")
+    @str.value.should == "abc\0\0"
   end
 
   it "should accept values exactly :length" do
     @str.value = "abcde"
-    @str.value.should eql("abcde")
+    @str.value.should == "abcde"
   end
 
   it "should truncate values greater than :length" do
     @str.value = "abcdefg"
-    @str.value.should eql("abcde")
+    @str.value.should == "abcde"
   end
 end
 
-describe "A String with :read_length and :initial_value" do
+describe BinData::String, "with :read_length and :initial_value" do
   before(:each) do
     @str = BinData::String.new(:read_length => 5, :initial_value => "abcdefghij")
   end
 
   it "should use :initial_value before value is read" do
-    @str.num_bytes.should eql(10)
-    @str.value.should eql("abcdefghij")
+    @str.num_bytes.should == 10
+    @str.value.should == "abcdefghij"
   end
 
   it "should use :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    io.pos.should eql(5)
+    io.pos.should == 5
    end
 
   it "should forget :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    @str.num_bytes.should eql(5)
-    @str.value.should eql("ABCDE")
+    @str.num_bytes.should == 5
+    @str.value.should == "ABCDE"
   end
 
 end
 
-describe "A String with :read_length and :value" do
+describe BinData::String, "with :read_length and :value" do
   before(:each) do
     @str = BinData::String.new(:read_length => 5, :value => "abcdefghij")
   end
 
   it "should not be affected by :read_length before value is read" do
-    @str.num_bytes.should eql(10)
-    @str.value.should eql("abcdefghij")
+    @str.num_bytes.should == 10
+    @str.value.should == "abcdefghij"
   end
 
   it "should use :read_length for reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    io.pos.should eql(5)
+    io.pos.should == 5
    end
 
   it "should not be affected by :read_length after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    @str.num_bytes.should eql(10)
-    @str.value.should eql("abcdefghij")
+    @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(io)
-    @str.value.should eql("ABCDE")
+    @str.value.should == "ABCDE"
 
     @str.done_read
-    @str.value.should eql("abcdefghij")
+    @str.value.should == "abcdefghij"
   end
 end
 
-describe "A String with :length and :initial_value" do
+describe BinData::String, "with :length and :initial_value" do
   before(:each) do
     @str = BinData::String.new(:length => 5, :initial_value => "abcdefghij")
   end
 
   it "should apply :length to :initial_value" do
-    @str.num_bytes.should eql(5)
-    @str.value.should eql("abcde")
+    @str.num_bytes.should == 5
+    @str.value.should == "abcde"
   end
 
   it "should forget :initial_value after reading" do
     io = StringIO.new("ABCDEFGHIJKLMNOPQRST")
     @str.read(io)
-    io.pos.should eql(5)
-    @str.num_bytes.should eql(5)
-    @str.value.should eql("ABCDE")
+    io.pos.should == 5
+    @str.num_bytes.should == 5
+    @str.value.should == "ABCDE"
   end
 end
 
-describe "A String with :pad_char" do
+describe BinData::String, "with :pad_char" do
   it "should accept a numeric value for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => 6)
     @str.value = "abc"
-    @str.value.should eql("abc\x06\x06")
+    @str.value.should == "abc\x06\x06"
   end
 
   it "should accept a character for :pad_char" do
     @str = BinData::String.new(:length => 5, :pad_char => "R")
     @str.value = "abc"
-    @str.value.should eql("abcRR")
+    @str.value.should == "abcRR"
   end
 
   it "should not accept a string for :pad_char" do
@@ -192,37 +192,37 @@ describe "A String with :pad_char" do
   end
 end
 
-describe "A String with :trim_value" do
+describe BinData::String, "with :trim_value" do
   it "set false is the default" do
     str1 = BinData::String.new(:length => 5)
     str2 = BinData::String.new(:length => 5, :trim_value => false)
     str1.value = "abc"
     str2.value = "abc"
-    str1.value.should eql("abc\0\0")
-    str2.value.should eql("abc\0\0")
+    str1.value.should == "abc\0\0"
+    str2.value.should == "abc\0\0"
   end
 
   it "should trim the value" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
-    str.value.should eql("abc")
+    str.value.should == "abc"
   end
 
   it "should not affect num_bytes" do
     str = BinData::String.new(:pad_char => 'R', :trim_value => true)
     str.value = "abcRR"
-    str.num_bytes.should eql(5)
+    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.value = "abcRR"
-    str.value.should eql("abc")
+    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.value = "abcRRde"
-    str.value.should eql("abcRRde")
+    str.value.should == "abcRRde"
   end
 end

data/spec/stringz_spec.rb

@@ -3,50 +3,50 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/stringz'
 
-describe "An empty Stringz data object" do
+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 eql(1)
+    @str.num_bytes.should == 1
   end
 
   it "should not append the zero byte terminator to the value" do
-    @str.value.should eql("")
+    @str.value.should == ""
   end
 
   it "should write the zero byte terminator" do
     io = StringIO.new
     @str.write(io)
     io.rewind
-    io.read.should eql("\0")
+    io.read.should == "\0"
   end
 end
 
-describe "A Stringz data object with value set" do
+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 eql(5)
+    @str.num_bytes.should == 5
   end
 
   it "should not append the zero byte terminator to the value" do
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should write the zero byte terminator" do
     io = StringIO.new
     @str.write(io)
     io.rewind
-    io.read.should eql("abcd\0")
+    io.read.should == "abcd\0"
   end
 end
 
-describe "Reading with a Stringz data object" do
+describe BinData::Stringz, "when reading" do
   before(:each) do
     @str = BinData::Stringz.new
   end
@@ -54,15 +54,15 @@ describe "Reading with a Stringz data object" do
   it "should stop at the first zero byte" do
     io = StringIO.new("abcd\0xyz\0")
     @str.read(io)
-    @str.value.should eql("abcd")
-    io.read(1).should eql("x")
+    @str.value.should == "abcd"
+    io.read(1).should == "x"
   end
 
   it "should handle a zero length string" do
     io = StringIO.new("\0abcd")
     @str.read(io)
-    @str.value.should eql("")
-    io.read(1).should eql("a")
+    @str.value.should == ""
+    io.read(1).should == "a"
   end
 
   it "should fail if no zero byte is found" do
@@ -71,38 +71,38 @@ describe "Reading with a Stringz data object" do
   end
 end
 
-describe "Setting the value of a Stringz data object" do
+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 eql(5)
+    @str.num_bytes.should == 5
   end
 
   it "should accept empty strings" do
     @str.value = ""
-    @str.value.should eql("")
+    @str.value.should == ""
   end
 
   it "should accept strings that aren't zero terminated" do
     @str.value = "abcd"
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should accept strings that are zero terminated" do
     @str.value = "abcd\0"
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should accept up to the first zero byte" do
     @str.value = "abcd\0xyz\0"
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 end
 
-describe "A Stringz data object with max_length" do
+describe BinData::Stringz, "with max_length" do
   before(:each) do
     @str = BinData::Stringz.new(:max_length => 5)
   end
@@ -110,35 +110,35 @@ describe "A Stringz data object with max_length" do
   it "should read less than max_length" do
     io = StringIO.new("abc\0xyz")
     @str.read(io)
-    @str.value.should eql("abc")
+    @str.value.should == "abc"
   end
 
   it "should read exactly max_length" do
     io = StringIO.new("abcd\0xyz")
     @str.read(io)
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should read no more than max_length" do
     io = StringIO.new("abcdefg\0xyz")
     @str.read(io)
-    @str.value.should eql("abcd")
-    io.read(1).should eql("f")
+    @str.value.should == "abcd"
+    io.read(1).should == "f"
   end
 
   it "should accept values less than max_length" do
     @str.value = "abc"
-    @str.value.should eql("abc")
+    @str.value.should == "abc"
   end
 
   it "should accept values exactly max_length" do
     @str.value = "abcd"
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should trim values greater than max_length" do
     @str.value = "abcde"
-    @str.value.should eql("abcd")
+    @str.value.should == "abcd"
   end
 
   it "should write values less than max_length" do
@@ -146,7 +146,7 @@ describe "A Stringz data object with max_length" do
     @str.value = "abc"
     @str.write(io)
     io.rewind
-    io.read.should eql("abc\0")
+    io.read.should == "abc\0"
   end
 
   it "should write values exactly max_length" do
@@ -154,6 +154,6 @@ describe "A Stringz data object with max_length" do
     @str.value = "abcd"
     @str.write(io)
     io.rewind
-    io.read.should eql("abcd\0")
+    io.read.should == "abcd\0"
   end
 end

data/spec/struct_spec.rb

@@ -3,18 +3,20 @@
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata'
 
-describe "A Struct with hidden fields" do
-  before(:all) do
-    eval <<-END
-      class HiddenStruct < BinData::Struct
-        hide :b, 'c'
-        int8 :a
-        int8 'b', :initial_value => 10
-        int8 :c
-        int8 :d, :value => :b
-      end
-    END
-    @obj = HiddenStruct.new
+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 not include hidden names in all_possible_field_names" do
+    params = BinData::SanitizedParameters.new(BinData::Struct, @params)
+    BinData::Struct.all_possible_field_names(params).should == ["a", "d"]
   end
 
   it "should only show fields that aren't hidden" do
@@ -22,9 +24,9 @@ describe "A Struct with hidden fields" do
   end
 
   it "should be able to access hidden fields directly" do
-    @obj.b.should eql(10)
+    @obj.b.should == 10
     @obj.c = 15
-    @obj.c.should eql(15)
+    @obj.c.should == 15
 
     @obj.should respond_to(:b=)
   end
@@ -35,187 +37,96 @@ describe "A Struct with hidden fields" do
   end
 end
 
-describe "A Struct that delegates" do
-  before(:all) do
-    eval <<-END
-      class DelegateStruct < BinData::Struct
-        delegate :b
-        int8 :a, :initial_value => :num
-        int8 'b', :initial_value => 7
-        int8 :c, :value => :b
-      end
-    END
-    @obj = DelegateStruct.new(:num => 5)
-  end
-
-  it "should access custom parameters" do
-    @obj.a.should eql(5)
-    @obj.b.should eql(7)
-  end
-
-  it "should have correct num_bytes" do
-    @obj.num_bytes.should eql(3)
-  end
-
-  it "should delegate snapshot" do
-    @obj.value = 6
-    @obj.snapshot.should eql(6)
-  end
-
-  it "should delegate single_value?" do
-    @obj.should be_a_single_value
-  end
-
-  it "should delegate methods" do
-    @obj.should respond_to(:value)
-    @obj.value = 9
-    @obj.c.should eql(9)
-  end
-
-  it "should identify accepted parameters" do
-    @obj.accepted_parameters.should include(:check_value)
-    @obj.accepted_parameters.should include(:initial_value)
-    @obj.accepted_parameters.should include(:value)
-    @obj.accepted_parameters.should_not include(:endian)
-  end
-
-  it "should pass params when creating" do
-    obj = DelegateStruct.new(:initial_value => :val, :val => 14)
-    obj.value.should eql(14)
-  end
-end
-
-describe "A Struct with nested delegation" do
-  before(:all) do
-    eval <<-END
-      class DelegateOuterStruct < BinData::Struct
-        endian :little
-        delegate :b
-        int8 :a
-        struct :b, :delegate => :y,
-                   :fields => [[:int8, :x], [:int32, :y], [:int8, :z]]
-      end
-    END
-    @obj = DelegateOuterStruct.new(:initial_value => 7)
-  end
-
-  it "should followed nested delegation" do
-    @obj.should be_a_single_value
-    @obj.field_names.should eql([])
-  end
-
-  it "should forward parameters" do
-    @obj.should respond_to(:value)
-    @obj.value.should eql(7)
-  end
-
-  it "should identify accepted parameters" do
-    @obj.accepted_parameters.should include(:check_value)
-    @obj.accepted_parameters.should include(:initial_value)
-    @obj.accepted_parameters.should include(:value)
-  end
-end
-
-describe "Defining a Struct" do
-  before(:all) do
-  end
+describe BinData::Struct do
   it "should fail on non registered types" do
+    params = {:fields => [[:non_registered_type, :a]]}
     lambda {
-      eval <<-END
-        class BadType < BinData::Struct
-          non_registerd_type :a
-        end
-      END
-    }.should raise_error(TypeError)
-
-    lambda {
-      BinData::Struct.new(:fields => [[:non_registered_type, :a]])
+      BinData::Struct.new(params)
     }.should raise_error(TypeError)
+  end
 
+  it "should fail on all_possible_field_names with unsanitized parameters" do
+    params = {:fields => [[:int8, :a], [:int8, :b]]}
     lambda {
-      BinData::Struct.new(:delegate => :a,
-                          :fields => [[:non_registered_type, :a]])
-    }.should raise_error(TypeError)
+      BinData::Struct.all_possible_field_names(params)
+    }.should raise_error(ArgumentError)
   end
 
   it "should fail on duplicate names" do
+    params = {:fields => [[:int8, :a], [:int8, :b], [:int8, :a]]}
     lambda {
-      eval <<-END
-        class DuplicateName < BinData::Struct
-          int8 :a
-          int8 :b
-          int8 :a
-        end
-      END
-    }.should raise_error(SyntaxError)
+      BinData::Struct.new(params)
+    }.should raise_error(NameError)
   end
 
-  it "should fail on reserved names" do
+  it "should fail on duplicate names in nested structs" do
+    params = {:fields => [[:int8, :a],
+                          [:struct, nil, {:fields => [[:int8, :a]]}]]}
     lambda {
-      eval <<-END
-        class ReservedName < BinData::Struct
-          int8 :a
-          int8 :invert # from Hash.instance_methods
-        end
-      END
+      BinData::Struct.new(params)
     }.should raise_error(NameError)
+  end
 
+  it "should fail on duplicate names in triple nested structs" do
+    params = {:fields => [[:int8, :a],
+                          [:struct, nil, {:fields => [
+                            [:struct, nil, {:fields => [[:int8, :a]]}]]}]]}
     lambda {
-      # :invert is from Hash.instance_methods
-      BinData::Struct.new(:fields => [[:int8, :a], [:int8, :invert]])
+      BinData::Struct.new(params)
     }.should raise_error(NameError)
   end
 
-  it "should fail on reserved names of delegated fields" do
+  it "should fail on reserved names" do
+    # note that #invert is from Hash.instance_methods
+    params = {:fields => [[:int8, :a], [:int8, :invert]]}
     lambda {
-      # :value is from Int8.instance_methods
-      BinData::Struct.new(:delegate => :a,
-                          :fields => [[:int8, :a], [:int8, :value]])
+      BinData::Struct.new(params)
     }.should raise_error(NameError)
   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 {
-      eval <<-END
-        class ExistingName < BinData::Struct
-          int8 :object_id
-        end
-      END
-    }.should raise_error(NameError)
-
-    lambda {
-      BinData::Struct.new(:fields => [[:int8, :object_id]])
+      BinData::Struct.new(params)
     }.should raise_error(NameError)
   end
 
   it "should fail on unknown endian" do
+    params = {:endian => 'bad value', :fields => []}
     lambda {
-      eval <<-END
-        class BadEndian < BinData::Struct
-          endian 'a bad value'
-        end
-      END
+      BinData::Struct.new(params)
     }.should raise_error(ArgumentError)
   end
 end
 
-describe "A Struct with multiple fields" do
+describe BinData::Struct, "with multiple fields" do
   before(:each) do
-    fields = [ [:int8, :a], [:int8, :b] ]
-    @obj = BinData::Struct.new(:fields => fields) 
+    @params = { :fields => [ [:int8, :a], [:int8, :b] ] }
+    @obj = BinData::Struct.new(@params)
     @obj.a = 1
     @obj.b = 2
   end
 
   it "should return num_bytes" do
-    @obj.num_bytes(:a).should eql(1)
-    @obj.num_bytes(:b).should eql(1)
-    @obj.num_bytes.should     eql(2)
+    @obj.num_bytes(:a).should == 1
+    @obj.num_bytes(:b).should == 1
+    @obj.num_bytes.should     == 2
   end
 
   it "should identify accepted parameters" do
-    @obj.accepted_parameters.should include(:delegate)
-    @obj.accepted_parameters.should include(:endian)
+    BinData::Struct.accepted_parameters.should include(:fields)
+    BinData::Struct.accepted_parameters.should include(:hide)
+    BinData::Struct.accepted_parameters.should include(:endian)
+  end
+
+  it "should return all possible field names" do
+    params = BinData::SanitizedParameters.new(BinData::Struct, @params)
+    BinData::Struct.all_possible_field_names(params).should == ["a", "b"]
+  end
+
+  it "should return field names" do
+    @obj.field_names.should == ["a", "b"]
   end
 
   it "should clear" do
@@ -237,21 +148,21 @@ describe "A Struct with multiple fields" do
     @obj.write(io)
 
     io.rewind
-    io.read.should eql("\x01\x02")
+    io.read.should == "\x01\x02"
   end
 
   it "should read ordered" do
     io = StringIO.new "\x03\x04"
     @obj.read(io)
 
-    @obj.a.should eql(3)
-    @obj.b.should eql(4)
+    @obj.a.should == 3
+    @obj.b.should == 4
   end
 
   it "should return a snapshot" do
     snap = @obj.snapshot
-    snap.a.should eql(1)
-    snap.b.should eql(2)
+    snap.a.should == 1
+    snap.b.should == 2
     snap.should == { "a" => 1, "b" => 2 }
   end
 
@@ -264,61 +175,64 @@ describe "A Struct with multiple fields" do
   end
 end
 
-describe "A Struct with nested structs" do
-  before(:all) do
-    eval <<-END
-      class StructInner1 < BinData::Struct
-        int8 :w, :initial_value => 3
-        int8 :x, :value => :the_val
-      end
+describe BinData::Struct, "with nested structs" do
+  before(:each) do
+    inner1 = [ [:int8, :w, {:initial_value => 3}],
+               [:int8, :x, {:value => :the_val}] ]
 
-      class StructInner2 < BinData::Struct
-        int8 :y, :value => lambda { parent.b.w }
-        int8 :z
-      end
+    inner2 = [ [:int8, :y, {:value => lambda { parent.b.w }}],
+               [:int8, :z] ]
 
-      class StructOuter < BinData::Struct
-        int8          :a, :initial_value => 6
-        struct_inner1 :b, :the_val => :a
-        struct_inner2 nil
-      end
-    END
-    @obj = StructOuter.new
+    @params = { :fields => [
+                  [:int8, :a, {:initial_value => 6}],
+                  [:struct, :b, {:fields => inner1, :the_val => :a}],
+                  [:struct, nil, {:fields => inner2}]] }
+    @obj = BinData::Struct.new(@params)
   end
 
   it "should included nested field names" do
     @obj.field_names.should == ["a", "b", "y", "z"]
   end
 
+  it "should return all possible field names" do
+    params = BinData::SanitizedParameters.new(BinData::Struct, @params)
+    all_params = BinData::Struct.all_possible_field_names(params)
+    all_params.should == ["a", "b", "y", "z"]
+  end
+
   it "should access nested fields" do
-    @obj.a.should   eql(6)
-    @obj.b.w.should eql(3)
-    @obj.b.x.should eql(6)
-    @obj.y.should   eql(3)
+    @obj.a.should   == 6
+    @obj.b.w.should == 3
+    @obj.b.x.should == 6
+    @obj.y.should   == 3
   end
 
   it "should return correct offset of" do
-    @obj.offset_of("b").should eql(1)
-    @obj.offset_of("y").should eql(3)
-    @obj.offset_of("z").should eql(4)
+    @obj.offset_of("b").should == 1
+    @obj.offset_of("y").should == 3
+    @obj.offset_of("z").should == 4
   end
 end
 
-describe "A Struct with an endian defined" do
-  before(:all) do
-    eval <<-END
-      class StructWithEndian < BinData::Struct
-        endian :little
-
-        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
-    END
-    @obj = StructWithEndian.new
+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
 
   it "should use correct endian" do