bindata 1.2.2 → 1.3.1

data/spec/bits_spec.rb

@@ -4,31 +4,29 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require 'bindata/bits'
 
 describe "Bits of size 1" do
-  before(:each) do
-    @bit_classes = [BinData::Bit1, BinData::Bit1le]
-  end
+  let(:bit_classes) { [BinData::Bit1, BinData::Bit1le] }
 
   it "should accept true as value" do
-    @bit_classes.each do |bit_class|
-      obj = bit_class.new
-      obj.value = true
-      obj.value.should == 1
+    bit_classes.each do |bit_class|
+      subject = bit_class.new
+      subject.assign(true)
+      subject.should == 1
     end
   end
 
   it "should accept false as value" do
-    @bit_classes.each do |bit_class|
-      obj = bit_class.new
-      obj.value = false
-      obj.value.should == 0
+    bit_classes.each do |bit_class|
+      subject = bit_class.new
+      subject.assign(false)
+      subject.should == 0
     end
   end
 
   it "should accept nil as value" do
-    @bit_classes.each do |bit_class|
-      obj = bit_class.new
-      obj.value = nil
-      obj.value.should == 0
+    bit_classes.each do |bit_class|
+      subject = bit_class.new
+      subject.assign(nil)
+      subject.should == 0
     end
   end
 end
@@ -37,35 +35,35 @@ share_examples_for "All bitfields" do
 
   it "should have a sensible value of zero" do
     all_classes do |bit_class|
-      bit_class.new.value.should be_zero
+      bit_class.new.should be_zero
     end
   end
 
   it "should avoid underflow" do
     all_classes do |bit_class|
-      obj = bit_class.new
+      subject = bit_class.new
 
-      obj.value = min_value - 1
-      obj.value.should == min_value
+      subject.assign(min_value - 1)
+      subject.should == min_value
     end
   end
 
   it "should avoid overflow" do
     all_classes do |bit_class|
-      obj = bit_class.new
+      subject = bit_class.new
 
-      obj.value = max_value + 1
-      obj.value.should == max_value
+      subject.assign(max_value + 1)
+      subject.should == max_value
     end
   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)
+        subject = bit_class.new
+        subject.assign(val)
 
-        obj.value.should == val
+        subject.should == val
       end
     end
   end
@@ -73,13 +71,10 @@ share_examples_for "All bitfields" do
   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)
-
-        obj = bit_class.new
-        obj.assign(src)
+        subject = bit_class.new
+        subject.assign(bit_class.new(val))
 
-        obj.value.should == val
+        subject.should == val
       end
     end
   end
@@ -87,11 +82,10 @@ share_examples_for "All bitfields" do
   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
+        subject = bit_class.new
+        subject.assign(val)
 
-        written = obj.to_binary_s
-        bit_class.read(written).should == val
+        subject.value_read_from_written.should == subject
       end
     end
   end
@@ -124,25 +118,29 @@ share_examples_for "All bitfields" do
   end
 end
 
+def generate_bit_classes_to_test(endian)
+  bits = {}
+  (1 .. 50).each do |nbits|
+    name = (endian == :big) ? "Bit#{nbits}" : "Bit#{nbits}le"
+    bit_class = BinData.const_get(name)
+    bits[bit_class] = nbits
+  end
+  bits
+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
+    @bits = generate_bit_classes_to_test(:big)
   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)
+
+      bit_class.read(str).should == 1 << (nbits - 1)
     end
   end
 end
@@ -151,21 +149,15 @@ 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
+    @bits = generate_bit_classes_to_test(:little)
   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
+
+      bit_class.read(str).should == 1
     end
   end
 end

data/spec/choice_spec.rb

@@ -8,6 +8,23 @@ class Chooser
   attr_accessor :choice
 end
 
+class BinData::Choice
+  def set_chooser(chooser)
+    @chooser = chooser
+  end
+  def choice=(s)
+    @chooser.choice = s
+  end
+end
+
+def create_choice(choices, options = {})
+  chooser = Chooser.new
+  params = {:choices => choices, :selection => lambda { chooser.choice } }.merge(options)
+  choice = BinData::Choice.new(params)
+  choice.set_chooser(chooser)
+  choice
+end
+
 describe BinData::Choice, "when instantiating" do
   it "should ensure mandatory parameters are supplied" do
     args = {}
@@ -41,170 +58,157 @@ end
 
 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
+    subject.choice = 3
+    subject.should == 30
   end
 
   it "should show the current selection" do
-    @chooser.choice = 3
-    @data.selection.should == 3
+    subject.choice = 3
+    subject.selection.should == 3
   end
 
   it "should not be able to directly change the current selection" do
     lambda {
-      @data.selection = 3
+      subject.selection = 3
     }.should raise_error(NoMethodError)
   end
 
   it "should forward #snapshot" do
-    @chooser.choice = 3
-    @data.snapshot.should == 30
+    subject.choice = 3
+    subject.snapshot.should == 30
   end
 
   it "should be able to change the choice" do
-    @chooser.choice = 3
+    subject.choice = 3
 
-    @chooser.choice = 7
-    @data.value.should == 70
+    subject.choice = 7
+    subject.should == 70
   end
 
   it "should fail if no choice has been set" do
-    lambda { @data.value }.should raise_error(IndexError)
+    lambda { subject.to_s }.should raise_error(IndexError)
   end
 
   it "should not be able to select an invalid choice" do
-    @chooser.choice = 99
-    lambda { @data.value }.should raise_error(IndexError)
+    subject.choice = 99
+    lambda { subject.to_s }.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)
+    subject.choice = 1
+    lambda { subject.to_s }.should raise_error(IndexError)
   end
 
   it "should handle missing methods correctly" do
-    @chooser.choice = 3
+    subject.choice = 3
 
-    @data.should respond_to(:value)
-    @data.should_not respond_to(:does_not_exist)
-    lambda { @data.does_not_exist }.should raise_error(NoMethodError)
+    subject.should respond_to(:value)
+    subject.should_not respond_to(:does_not_exist)
+    lambda { subject.does_not_exist }.should raise_error(NoMethodError)
   end
 
   it "should delegate methods to the selected single choice" do
-    @chooser.choice = 5
-
-    @data.num_bytes.should == ExampleSingle.new.num_bytes
+    subject.choice = 5
+    subject.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,
-                                             [:example_single, {:value => 30}],
-                                             nil,
-                                             [:example_single, {:value => 50}],
-                                             nil,
-                                             [:example_single, {:value => 70}]],
-                                :selection => lambda { chooser.choice } )
-    @chooser = chooser
-  end
+  subject {
+    choices = [nil, nil, nil,
+               [:example_single, {:value => 30}], nil,
+               [:example_single, {:value => 50}], nil,
+               [:example_single, {:value => 70}]]
+    create_choice(choices)
+  }
 end
 
 describe BinData::Choice, "with choices hash" do
   it_should_behave_like "Choice initialized with array or hash"
 
-  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
+  subject {
+    choices = {3 => [:example_single, {:value => 30}],
+               5 => [:example_single, {:value => 50}],
+               7 => [:example_single, {:value => 70}]}
+    create_choice(choices)
+  }
 end
 
 describe BinData::Choice, "with single values" do
-  before(:each) do
-    chooser = Chooser.new
-    @data = BinData::Choice.new(:choices => {3 => :example_single,
-                                             5 => :example_single,
-                                             7 => :example_single,},
-                                :selection => lambda { chooser.choice } )
-    @chooser = chooser
-  end
+  subject {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices)
+  }
 
   it "should assign raw values" do
-    @chooser.choice = 3
-    @data.value = 254
-    @data.value.should == 254
+    subject.choice = 3
+    subject.assign(254)
+    subject.should == 254
   end
 
   it "should assign Single values" do
-    obj = ExampleSingle.new
-    obj.value = 11
+    obj = ExampleSingle.new(11)
 
-    @chooser.choice = 3
-    @data.value = obj
-    @data.value.should == 11
+    subject.choice = 3
+    subject.assign(obj)
+    subject.should == 11
   end
 
   it "should clear" do
-    @chooser.choice = 3
-    @data.value = 254
+    subject.choice = 3
+    subject.assign(254)
 
-    @data.clear
-    @data.value.should be_zero
+    subject.clear
+    subject.should be_zero
   end
 
   it "should be clear on initialisation" do
-    @chooser.choice = 3
+    subject.choice = 3
 
-    @data.should be_clear
+    subject.should be_clear
   end
 
   it "should not be clear after assignment" do
-    @chooser.choice = 3
-    @data.value = 254
+    subject.choice = 3
+    subject.assign(254)
 
-    @data.should_not be_clear
+    subject.should_not be_clear
   end
 
   it "should not copy value when changing selection" do
-    @chooser.choice = 3
-    @data.value = 254
+    subject.choice = 3
+    subject.assign(254)
 
-    @chooser.choice = 7
-    @data.value.should_not == 254
+    subject.choice = 7
+    subject.should_not == 254
   end
 
   it "should behave as value" do
-    @chooser.choice = 3
-    @data.value = 5
+    subject.choice = 3
+    subject.assign(5)
 
-    (@data + 1).should == 6
-    (1 + @data).should == 6
+    (subject + 1).should == 6
+    (1 + subject).should == 6
   end
 end
 
 describe BinData::Choice, "with copy_on_change => true" do
-  before(:each) do
-    chooser = Chooser.new
-    @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
+  subject {
+    choices = {3 => :example_single,
+               5 => :example_single,
+               7 => :example_single}
+    create_choice(choices, :copy_on_change => true)
+  }
 
   it "should copy value when changing selection" do
-    @chooser.choice = 3
-    @data.value = 254
+    subject.choice = 3
+    subject.assign(254)
 
-    @chooser.choice = 7
-    @data.value.should == 254
+    subject.choice = 7
+    subject.should == 254
   end
 end