bindata 0.9.3 → 0.10.0

data/spec/bits_spec.rb

@@ -4,136 +4,164 @@ require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
 require 'bindata/bits'
 
 describe "Bits of size 1" do
-  it "should accept true as value" do
-    obj = BinData::Bit1.new
-    obj.value = true
-    obj.value.should == 1
+  before(:each) do
+    @bit_classes = [BinData::Bit1, BinData::Bit1le]
+  end
 
-    obj = BinData::Bit1le.new
-    obj.value = true
-    obj.value.should == 1
+  it "should accept true as value" do
+    @bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.value = true
+      obj.value.should == 1
+    end
   end
 
   it "should accept false as value" do
-    obj = BinData::Bit1.new
-    obj.value = false
-    obj.value.should == 0
-
-    obj = BinData::Bit1le.new
-    obj.value = false
-    obj.value.should == 0
+    @bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.value = false
+      obj.value.should == 0
+    end
   end
 
   it "should accept nil as value" do
-    obj = BinData::Bit1.new
-    obj.value = nil
-    obj.value.should == 0
-
-    obj = BinData::Bit1le.new
-    obj.value = nil
-    obj.value.should == 0
+    @bit_classes.each do |bit_class|
+      obj = bit_class.new
+      obj.value = nil
+      obj.value.should == 0
+    end
   end
 end
 
-describe "All bitfields" do
+share_examples_for "All bitfields" do
+
   it "should have a sensible value of zero" do
-    begin
-      nbits = 1
-      loop do
-        ["", "le"].each do |suffix|
-          klass = BinData.const_get("Bit#{nbits}#{suffix}")
-          klass.new.value.should be_zero
-        end
-
-        nbits += 1
-      end
-    rescue NameError
+    all_classes do |bit_class|
+      bit_class.new.value.should be_zero
+    end
+  end
+
+  it "should avoid underflow" do
+    all_classes do |bit_class|
+      obj = bit_class.new
+
+      obj.value = min_value - 1
+      obj.value.should == min_value
     end
   end
 
-  it "should clamp " do
-    begin
-      nbits = 1
-      loop do
-        ["", "le"].each do |suffix|
-          klass = BinData.const_get("Bit#{nbits}#{suffix}")
-          obj = klass.new
+  it "should avoid overflow" do
+    all_classes do |bit_class|
+      obj = bit_class.new
 
-          obj.value = -1
-          obj.value.should == 0
+      obj.value = max_value + 1
+      obj.value.should == max_value
+    end
+  end
 
-          obj.value = 1 << nbits
-          obj.value.should == ((1 << nbits) - 1)
-        end
+  it "should assign values" do
+    all_classes do |bit_class|
+      some_values_within_range.each do |val|
+        obj = bit_class.new
+        obj.assign(val)
 
-        nbits += 1
+        obj.value.should == val
       end
-    rescue NameError
     end
   end
 
-  it "should read big endian value" do
-    begin
-      nbits = 1
-      loop do
-        klass = BinData.const_get("Bit#{nbits}")
-        obj = klass.new
+  it "should assign values from other bit objects" do
+    all_classes do |bit_class|
+      some_values_within_range.each do |val|
+        src = bit_class.new
+        src.assign(val)
 
-        str = [0b1000_0000].pack("C") + "\000" * (nbits / 8)
-        obj.read(str)
-        obj.value.should == 1 << (nbits - 1)
+        obj = bit_class.new
+        obj.assign(src)
 
-        nbits += 1
+        obj.value.should == val
       end
-    rescue NameError
     end
   end
 
-  it "should read little endian value" do
-    begin
-      nbits = 1
-      loop do
-        klass = BinData.const_get("Bit#{nbits}le")
-        obj = klass.new
-
-        str = [0b0000_0001].pack("C") + "\000" * (nbits / 8)
-        obj.read(str)
-        obj.value.should == 1
+  it "should have symmetric #read and #write" do
+    all_classes do |bit_class|
+      some_values_within_range.each do |val|
+        obj = bit_class.new
+        obj.value = val
 
-        nbits += 1
+        written = obj.to_binary_s
+        bit_class.read(written).should == val
       end
-    rescue NameError
     end
   end
 
-  it "should read written values" do
-    begin
-      nbits = 1
-      loop do
-        ["", "le"].each do |suffix|
-          klass = BinData.const_get("Bit#{nbits}#{suffix}")
-
-          min = 0
-          max = (1 << nbits) - 1
-          range = (min .. max)
-
-          values = []
-          values << (min + 1) if range.include?(min + 1)
-          values << (min + 3) if range.include?(min + 3)
-          values << (max - 1) if range.include?(max - 1)
-
-          values.each do |val|
-            obj = klass.new
-            obj.value = val
-            str = obj.to_s
-            obj.read(str)
-            obj.value.should == val
-          end
-        end
-
-        nbits += 1
-      end
-    rescue NameError
+  def all_classes(&block)
+    @bits.each_pair do |bit_class, nbits|
+      @nbits = nbits
+      yield bit_class
+    end
+  end
+
+  def min_value
+    0
+  end
+
+  def max_value
+    (1 << @nbits) - 1
+  end
+
+  def some_values_within_range
+    lo  = min_value + 1
+    mid = (min_value + max_value) / 2
+    hi  = max_value - 1
+
+    [lo, mid, hi].find_all { |v| (min_value .. max_value).include?(v) }
+  end
+end
+
+describe "Big endian bitfields" do
+  it_should_behave_like "All bitfields"
+
+  before(:all) do
+    @bits = {}
+    (1 .. 63).each do |nbits|
+      bit_class = BinData.const_get("Bit#{nbits}")
+      @bits[bit_class] = nbits
+    end
+  end
+
+  it "should read big endian value" do
+    @bits.each_pair do |bit_class, nbits|
+      obj = bit_class.new
+
+      nbytes = (nbits + 7) / 8
+      str = [0b1000_0000].pack("C") + "\000" * (nbytes - 1)
+      obj.read(str)
+      obj.value.should == 1 << (nbits - 1)
+    end
+  end
+end
+
+describe "Little endian bitfields" do
+  it_should_behave_like "All bitfields"
+
+  before(:all) do
+    @bits = {}
+    (1 .. 63).each do |nbits|
+      bit_class = BinData.const_get("Bit#{nbits}le")
+      @bits[bit_class] = nbits
+    end
+  end
+
+  it "should read little endian value" do
+    @bits.each_pair do |bit_class, nbits|
+      obj = bit_class.new
+
+      nbytes = (nbits + 7) / 8
+      str = [0b0000_0001].pack("C") + "\000" * (nbytes - 1)
+      obj.read(str)
+      obj.value.should == 1
     end
   end
 end

data/spec/choice_spec.rb

@@ -1,10 +1,8 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__)) + '/spec_common'
+require File.expand_path(File.dirname(__FILE__)) + '/example'
 require 'bindata/choice'
-require 'bindata/int'
-require 'bindata/lazy'
-require 'bindata/struct'
 
 class Chooser
   attr_accessor :choice
@@ -31,42 +29,35 @@ describe BinData::Choice, "when instantiating" do
   end
 
   it "should fail if :choices Hash has a symbol as key" do
-    args = {:choices => {:a => :int8}, :selection => 0}
+    args = {:choices => {:a => :example_single}, :selection => 0}
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
   end
 
   it "should fail if :choices Hash has a nil key" do
-    args = {:choices => {nil => :int8}, :selection => 0}
+    args = {:choices => {nil => :example_single}, :selection => 0}
     lambda { BinData::Choice.new(args) }.should raise_error(ArgumentError)
   end
 end
 
-describe BinData::Choice, "with choices array" do
-  before(:each) do
-    chooser = Chooser.new
-    @data = BinData::Choice.new(:choices => [[:int8,    {:value => 3}],
-                                             [:int16le, {:value => 5}],
-                                             [:int32le, {:value => 7}]],
-                                :selection => lambda { chooser.choice } )
-    @chooser = chooser
+share_examples_for "Choice initialized with array or hash" do
+  it "should be able to select the choice" do
+    @chooser.choice = 3
+    @data.value.should == 30
   end
 
-  it "should be able to select the choice" do
-    @chooser.choice = 0
-    @data.selection.should == 0
-    @data.value.should == 3
+  it "should show the current selection" do
+    @chooser.choice = 3
+    @data.selection.should == 3
+  end
 
-    @chooser.choice = 1
-    @data.selection.should == 1
-    @data.value.should == 5
+  it "should be able to change the choice" do
+    @chooser.choice = 3
 
-    @chooser.choice = 2
-    @data.selection.should == 2
-    @data.value.should == 7
+    @chooser.choice = 7
+    @data.value.should == 70
   end
 
-  it "should handle :selection returning nil" do
-    @chooser.choice = nil
+  it "should fail if no choice has been set" do
     lambda { @data.value }.should raise_error(IndexError)
   end
 
@@ -75,8 +66,13 @@ describe BinData::Choice, "with choices array" do
     lambda { @data.value }.should raise_error(IndexError)
   end
 
+  it "should not be able to select a nil choice" do
+    @chooser.choice = 1
+    lambda { @data.value }.should raise_error(IndexError)
+  end
+
   it "should handle missing methods correctly" do
-    @chooser.choice = 0
+    @chooser.choice = 3
 
     @data.should respond_to(:value)
     @data.should_not respond_to(:does_not_exist)
@@ -84,125 +80,120 @@ describe BinData::Choice, "with choices array" do
   end
 
   it "should delegate methods to the selected single choice" do
-    @chooser.choice = 1
+    @chooser.choice = 5
 
-    @data.num_bytes.should == 2
+    @data.num_bytes.should == ExampleSingle.new.num_bytes
   end
 end
 
 describe BinData::Choice, "with sparse choices array" do
+  it_should_behave_like "Choice initialized with array or hash"
+
   before(:each) do
     chooser = Chooser.new
     @data = BinData::Choice.new(:choices => [nil, nil, nil,
-                                             [:int8,    {:value => 3}],
+                                             [:example_single, {:value => 30}],
                                              nil,
-                                             [:int16le, {:value => 5}],
+                                             [:example_single, {:value => 50}],
                                              nil,
-                                             [:int32le, {:value => 7}]],
+                                             [:example_single, {:value => 70}]],
                                 :selection => lambda { chooser.choice } )
     @chooser = chooser
   end
+end
 
-  it "should be able to select the choice" do
-    @chooser.choice = 3
-    @data.selection.should == 3
-    @data.value.should == 3
-
-    @chooser.choice = 7
-    @data.selection.should == 7
-    @data.value.should == 7
-  end
-
-  it "should not be able to select an invalid choice" do
-    @chooser.choice = 99
-    lambda { @data.value }.should raise_error(IndexError)
-  end
+describe BinData::Choice, "with choices hash" do
+  it_should_behave_like "Choice initialized with array or hash"
 
-  it "should not be able to select a nil choice" do
-    @chooser.choice = 1
-    lambda { @data.value }.should raise_error(IndexError)
+  before(:each) do
+    chooser = Chooser.new
+    @data = BinData::Choice.new(:choices => {3 => [:example_single, {:value => 30}],
+                                             5 => [:example_single, {:value => 50}],
+                                             7 => [:example_single, {:value => 70}]},
+                                :selection => lambda { chooser.choice } )
+    @chooser = chooser
   end
 end
 
-describe BinData::Choice, "with choices hash" do
+describe BinData::Choice, "with single values" do
   before(:each) do
     chooser = Chooser.new
-    @data = BinData::Choice.new(:choices => {3 => [:int8,    {:value => 3}],
-                                             5 => [:int16le, {:value => 5}],
-                                             7 => [:int32le, {:value => 7}]},
+    @data = BinData::Choice.new(:choices => {3 => :example_single,
+                                             5 => :example_single,
+                                             7 => :example_single,},
                                 :selection => lambda { chooser.choice } )
     @chooser = chooser
   end
 
-  it "should be able to select the choice" do
+  it "should assign raw values" do
     @chooser.choice = 3
-    @data.value.should == 3
-    @data.selection.should == 3
+    @data.value = 254
+    @data.value.should == 254
+  end
 
-    @chooser.choice = 7
-    @data.value.should == 7
-    @data.selection.should == 7
+  it "should assign Single values" do
+    obj = ExampleSingle.new
+    obj.value = 11
+
+    @chooser.choice = 3
+    @data.value = obj
+    @data.value.should == 11
   end
 
-  it "should not be able to select an invalid choice" do
-    @chooser.choice = 99
-    lambda { @data.value }.should raise_error(IndexError)
+  it "should clear" do
+    @chooser.choice = 3
+    @data.value = 254
+
+    @data.clear
+    @data.value.should be_zero
   end
-end
 
-describe BinData::Choice, "with single values" do
-  before(:each) do
-    chooser = Chooser.new
-    @data = BinData::Choice.new(:choices => {3 => :uint8,
-                                             5 => :uint16le,
-                                             7 => :uint32le,},
-                                :selection => lambda { chooser.choice } )
-    @chooser = chooser
+  it "should be clear on initialisation" do
+    @chooser.choice = 3
+
+    @data.should be_clear
   end
 
-  it "should copy value when changing selection" do
+  it "should not be clear after assignment" do
     @chooser.choice = 3
     @data.value = 254
 
-    @data.to_s.should == "\xfe"
+    @data.should_not be_clear
+  end
 
-    @chooser.choice = 5
-    @data.to_s.should == "\xfe\x00"
+  it "should not copy value when changing selection" do
+    @chooser.choice = 3
+    @data.value = 254
 
     @chooser.choice = 7
-    @data.to_s.should == "\xfe\x00\x00\x00"
+    @data.value.should_not == 254
+  end
+
+  it "should behave as value" do
+    @chooser.choice = 3
+    @data.value = 5
+
+    (@data + 1).should == 6
+    (1 + @data).should == 6
   end
 end
 
-describe BinData::Choice, "with multi values" do
+describe BinData::Choice, "with copy_on_change => true" do
   before(:each) do
     chooser = Chooser.new
-    @data = BinData::Choice.new(:choices =>
-                                  {3 => [:struct, {:fields => [[:int8,  :a]]}],
-                                   5 => [:struct, {:fields => [[:int8,  :a]]}]},
-                                :selection => lambda { chooser.choice } )
+    @data = BinData::Choice.new(:choices => {3 => :example_single,
+                                             5 => :example_single,
+                                             7 => :example_single,},
+                                :selection => lambda { chooser.choice },
+                                :copy_on_change => true)
     @chooser = chooser
   end
 
-  it "should access fields" do
-    @chooser.choice = 3
-    @data.a = 5
-    @data.a.should == 5
-  end
-
-  it "should not copy values when changing fields" do
-    @chooser.choice = 3
-    @data.a = 5
-    @data.a.should == 5
-
-    @chooser.choice = 5
-    @data.a = 17
-    @data.a.should == 17
-
+  it "should copy value when changing selection" do
     @chooser.choice = 3
-    @data.a.should == 5
+    @data.value = 254
 
-    @chooser.choice = 5
-    @data.a.should == 17
+    @chooser.choice = 7
+    @data.value.should == 254
   end
 end