gecoder-with-gecode 0.7.1-mswin32 → 0.8.0-mswin32

data/specs/constraints/bool_enum.rb

@@ -79,17 +79,27 @@ describe Gecode::Constraints::BoolEnum, ' (conjunction)' do
       @bools.conjunction.must_be.equal_to(true, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
-        Gecode::Raw.should_receive(:bool_and).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::BoolVarArray), 
-          an_instance_of(Gecode::Raw::BoolVar), strength)
-        unless reif_var.nil?
-          Gecode::Raw.should_receive(:bool_eqv).once.with(
-            an_instance_of(Gecode::Raw::Space), 
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space),
+            Gecode::Raw::BOT_AND, 
+            an_instance_of(Gecode::Raw::BoolVarArray),
             an_instance_of(Gecode::Raw::BoolVar), 
-            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+            strength, kind)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar),
+            anything,
+            an_instance_of(Gecode::Raw::BoolVar),
+            anything, anything, anything)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            Gecode::Raw::BOT_AND, 
+            an_instance_of(Gecode::Raw::BoolVarArray),
+            reif_var, strength, kind)
         end
       end
     end
@@ -100,7 +110,7 @@ describe Gecode::Constraints::BoolEnum, ' (conjunction)' do
   end
   
   it_should_behave_like 'bool enum constraint'
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end
 
 describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
@@ -115,17 +125,27 @@ describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
       @bools.disjunction.must_be.equal_to(true, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
-        Gecode::Raw.should_receive(:bool_or).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::BoolVarArray), 
-          an_instance_of(Gecode::Raw::BoolVar), strength)
-        unless reif_var.nil?
-          Gecode::Raw.should_receive(:bool_eqv).once.with(
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
+            Gecode::Raw::BOT_OR, 
+            an_instance_of(Gecode::Raw::BoolVarArray),
             an_instance_of(Gecode::Raw::BoolVar), 
-            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+            strength, kind)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar),
+            anything,
+            an_instance_of(Gecode::Raw::BoolVar),
+            anything, anything, anything)          
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            Gecode::Raw::BOT_OR, 
+            an_instance_of(Gecode::Raw::BoolVarArray),
+            reif_var, strength, kind)
         end
       end
     end
@@ -136,5 +156,5 @@ describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
   end
   
   it_should_behave_like 'bool enum constraint'
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/boolean.rb

@@ -25,19 +25,20 @@ describe Gecode::Constraints::Bool do
       (@b1 | @b2).must_be.equal_to(true, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
-        Gecode::Raw.should_receive(:bool_or).once.with(
+        Gecode::Raw.should_receive(:rel).once.with(
           an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVar),
+          Gecode::Raw::BOT_OR, 
           an_instance_of(Gecode::Raw::BoolVar), 
-          an_instance_of(Gecode::Raw::BoolVar), 
-          an_instance_of(Gecode::Raw::BoolVar), 
-          Gecode::Raw::ICL_DEF)
+          an_instance_of(Gecode::Raw::BoolVar),
+          Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
         unless reif_var.nil?
-          Gecode::Raw.should_receive(:bool_eqv).once.with(
+          Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), 
-            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+            an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::BOT_EQV, 
+            an_instance_of(Gecode::Raw::BoolVar), 1, strength, kind)
         end
       end
     end
@@ -227,6 +228,5 @@ describe Gecode::Constraints::Bool do
     sol.b3.value.should be_true
   end
   
-  
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/cardinality.rb

@@ -49,11 +49,13 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
   it 'should not shadow the integer variable domain constrain' do
     Gecode::Raw.should_receive(:dom).with(
       an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), 0, 11, Gecode::Raw::ICL_DEF)
+      an_instance_of(Gecode::Raw::IntVar), 0, 11, Gecode::Raw::ICL_DEF, 
+      Gecode::Raw::PK_DEF)
     Gecode::Raw.should_receive(:dom).with(
       an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), an_instance_of(Gecode::Raw::IntSet), 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF, 
+      Gecode::Raw::PK_DEF)
     @set.size.must_not_be.in [1,3]
     @model.solve!
   end
@@ -73,7 +75,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
       @set.size.must == rhs 
       @model.solve!
     end
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -91,7 +93,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:cardinality).once.with(
@@ -102,7 +104,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs,
             an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            strength, kind)
         end
       end
     end
@@ -117,7 +119,8 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
       @model.solve!
     end
     @expect_relation = lambda do |relation, target, negated|
-      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF,  Gecode::Raw::PK_DEF,
+        nil, negated)
     end
     
     # For options spec.
@@ -125,8 +128,8 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
       @set.size.must_be.less_than_or_equal_to(17, hash)
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_LQ, 17, strength, reif_var, false)
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      @expect.call(Gecode::Raw::IRT_LQ, 17, strength, kind, reif_var, false)
     end
   end
   
@@ -149,6 +152,6 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
     @set.value.size.should == 2
   end
   
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
   it_should_behave_like 'composite constraint'
 end

data/specs/constraints/channel.rb

@@ -25,18 +25,18 @@ describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
       @positions.must.channel @elements, hash
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       Gecode::Raw.should_receive(:channel).once.with(
         an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVarArray), strength)
+        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
     end
   end
 
   it 'should translate into a channel constraint' do
     Gecode::Raw.should_receive(:channel).once.with(
       an_instance_of(Gecode::Raw::Space), 
-      anything, anything, Gecode::Raw::ICL_DEF)
+      anything, anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
     @invoke_options.call({})
   end
 
@@ -59,7 +59,7 @@ describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
     lambda{ @elements.must.channel 'hello' }.should raise_error(TypeError) 
   end
   
-  it_should_behave_like 'constraint with strength option'
+  it_should_behave_like 'reifiable constraint'
 end
 
 describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum)' do
@@ -99,7 +99,7 @@ describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' d
       @sets.must.channel @positions, hash
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       Gecode::Raw.should_receive(:channel).once.with(
         an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVarArray), 
@@ -108,7 +108,7 @@ describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' d
   end
 
   it 'should translate into a channel constraint' do
-    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @expect_options.call({})
     @sets.must.channel @positions
     @model.solve!
   end

data/specs/constraints/connection.rb

@@ -19,7 +19,8 @@ describe 'connection constraint', :shared => true do
       @model.solve!
     end
     @expect_relation = lambda do |relation, target, negated|
-      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF,
+        nil, negated)
     end
     
     # For options spec.
@@ -27,12 +28,12 @@ describe 'connection constraint', :shared => true do
       @stub.must_be.less_than_or_equal_to(17, hash)
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_LQ, 17, strength, reif_var, false)
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      @expect.call(Gecode::Raw::IRT_LQ, 17, strength, kind, reif_var, false)
     end
   end
   
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
   it_should_behave_like 'composite constraint'
 end
 
@@ -44,7 +45,7 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
     @model.branch_on @model.wrap_enum([@set])
     @stub = @set.min
     
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -62,7 +63,7 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:min).once.with(
@@ -72,8 +73,7 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -96,7 +96,7 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
     @model.branch_on @model.wrap_enum([@set])
     @stub = @set.max
     
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -114,7 +114,7 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:max).once.with(
@@ -124,8 +124,7 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -148,7 +147,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
     @model.branch_on @model.wrap_enum([@set])
     @stub = @set.sum
     
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -167,7 +166,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:weights).once.with(
@@ -177,8 +176,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -214,7 +212,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
     @weights = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
     @stub = @set.sum(:weights => @weights)
     
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -232,7 +230,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:weights).once.with(
@@ -242,8 +240,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -275,7 +272,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
     @subs = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
     @stub = @set.sum(:substitutions => @subs)
     
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -293,7 +290,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength)
+              strength, kind)
           end
         else
           Gecode::Raw.should_receive(:weights).once.with(
@@ -303,8 +300,7 @@ describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -339,7 +335,7 @@ describe Gecode::Constraints::Set::Connection, ' (include)' do
       end
     end
     
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       @expect.call(@array, strength, reif_var)
     end
     @invoke_options = lambda do |hash|
@@ -349,7 +345,7 @@ describe Gecode::Constraints::Set::Connection, ' (include)' do
   end
   
   it 'should translate to a match constraint' do
-    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @expect_options.call({})
     @set.must.include @array
     @model.solve!
   end

data/specs/constraints/constraint_helper.rb

@@ -1,7 +1,28 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-# This requires that the constraint spec has instance variables @invoke_options
-# and @expect_options .
+# Several of these shared specs requires one or more of the following instance 
+# variables to be used: 
+# [@expect_options]  A method that creates an expectation on the aspect to be 
+#                    tested, using the provided hash of Gecode values. The hash 
+#                    can have values for the keys :icl (ICL_*), :pk (PK_*), and 
+#                    :bool (bound reification variable). Any values not 
+#                    provided are assumed to be default values (nil in the case 
+#                    of :bool).
+# [@invoke_options]  A method that invokes the aspect to be tested, with the 
+#                    provided hash of options (with at most the keys :strength, 
+#                    :kind and :reify).
+# [@model]           The model instance that contains the aspects being tested.
+# [@expect_relation] A method that takes a relation, right hand side, and 
+#                    whether it's negated, as arguments and sets up the 
+#                    corresponding expectations. 
+# [@invoke_relation] A method that takes a relation, right hand side, and 
+#                    whether it's negated, as arguments and adds the 
+#                    corresponding constraint and invokes it.
+# [@target]          A legal right hand side that can be used as argument to 
+#                    the above two methods.
+
+
+# Requires @invoke_options and @expect_options.
 describe 'constraint with strength option', :shared => true do
   { :default  => Gecode::Raw::ICL_DEF,
     :value    => Gecode::Raw::ICL_VAL,
@@ -9,49 +30,92 @@ describe 'constraint with strength option', :shared => true do
     :domain   => Gecode::Raw::ICL_DOM
   }.each_pair do |name, gecode_value|
     it "should translate propagation strength #{name}" do
-      @expect_options.call(gecode_value, nil)
+      @expect_options.call(:icl => gecode_value)
       @invoke_options.call(:strength => name)
     end
   end
   
   it 'should default to using default as propagation strength' do
-    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @expect_options.call({})
     @invoke_options.call({})
   end
   
-  it 'should raise errors for unrecognized options' do
-    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
-      raise_error(ArgumentError))
+  it 'should raise errors for unrecognized propagation strengths' do
+    lambda do 
+      @invoke_options.call(:strength => :does_not_exist) 
+    end.should raise_error(ArgumentError)
+  end
+end
+
+# Requires @invoke_options and @expect_options.
+describe 'constraint with kind option', :shared => true do
+  { :default  => Gecode::Raw::PK_DEF,
+    :speed    => Gecode::Raw::PK_SPEED,
+    :memory   => Gecode::Raw::PK_MEMORY
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation kind #{name}" do
+      @expect_options.call(:pk => gecode_value)
+      @invoke_options.call(:kind => name)
+    end
   end
   
-  it 'should raise errors for unrecognized propagation strengths' do
-    lambda{ @invoke_options.call(:strength => :does_not_exist) }.should(
-      raise_error(ArgumentError))
+  it 'should default to using default as propagation kind' do
+    @expect_options.call({})
+    @invoke_options.call({})
   end
   
-  it 'should raise errors for reification variables of incorrect type' do
-    lambda{ @invoke_options.call(:reify => 'foo') }.should(
-      raise_error(TypeError))
+  it 'should raise errors for unrecognized propagation kinds' do
+    lambda do 
+      @invoke_options.call(:kind => :does_not_exist)
+    end.should raise_error(ArgumentError)
   end
 end
 
-# This requires that the constraint spec has instance variables @invoke_options
-# and @expect_options .
-describe 'constraint with options', :shared => true do
+
+# Requires @invoke_options and @expect_options.
+describe 'constraint with reification option', :shared => true do
   it 'should translate reification' do
     var = @model.bool_var
-    @expect_options.call(Gecode::Raw::ICL_DEF, var)
+    @expect_options.call(:bool => var)
     @invoke_options.call(:reify => var)
   end
   
+  it 'should raise errors for reification variables of incorrect type' do
+    lambda do 
+      @invoke_options.call(:reify => 'foo')
+    end.should raise_error(TypeError)
+  end
+end
+
+# Requires @invoke_options and @expect_options.
+describe 'reifiable constraint', :shared => true do
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint with reification option'
+end
+
+# Requires @invoke_options, @expect_options and @model.
+describe 'non-reifiable constraint', :shared => true do
+  it 'should raise errors if reification is used' do
+    lambda do 
+      @invoke_options.call(:reify => @model.bool_var)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'constraint with default options'
+end
+
+# Requires @invoke_options and @expect_options.
+describe 'constraint with default options', :shared => true do
+  it 'should raise errors for unrecognized options' do
+    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
+      raise_error(ArgumentError))
+  end
+  
   it_should_behave_like 'constraint with strength option'
+  it_should_behave_like 'constraint with kind option'
 end
 
-# This requires that the constraint spec has the instance variable 
-# @expect_relation which takes a relation, right hand side and whether it's 
-# negated as arguments and sets up the corresponding expectations. It also 
-# requires @invoke_relation with the same arguments. The spec is also required 
-# to provide a variable @target.
+# Requires @expect_relation, @invoke_relation and @target.
 describe 'composite constraint', :shared => true do
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant target" do
@@ -88,11 +152,7 @@ describe 'composite constraint', :shared => true do
   end
 end
 
-# This requires that the constraint spec has the instance variable 
-# @expect_relation which takes a relation, right hand side and whether it's 
-# negated as arguments and sets up the corresponding expectations. It also 
-# requires @invoke_relation with the same arguments. The spec is also required 
-# to provide a variable @target.
+# Requires @expect_relation, @invoke_relation and @target.
 describe 'composite set constraint', :shared => true do
   Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant target" do
@@ -129,35 +189,42 @@ describe 'composite set constraint', :shared => true do
   end
 end
 
-# Requires @invoke_options and @model.
-describe 'non-reifiable set constraint', :shared => true do
+describe 'set constraint', :shared => true do
   it 'should not accept strength option' do
     lambda do 
       @invoke_options.call(:strength => :default)
     end.should raise_error(ArgumentError)
   end
   
+  it 'should not accept kind option' do
+    lambda do 
+      @invoke_options.call(:kind => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized options' do
+    lambda do 
+      @invoke_options.call(:does_not_exist => :foo) 
+    end.should raise_error(ArgumentError)
+  end
+end
+
+# Requires @invoke_options and @model.
+describe 'non-reifiable set constraint', :shared => true do
   it 'should not accept reification option' do
     bool = @model.bool_var
     lambda do 
       @invoke_options.call(:reify => bool)
     end.should raise_error(ArgumentError)
   end
+  
+  it_should_behave_like 'set constraint'
 end
 
 # Requires @invoke_options, @expect_options and @model.
 describe 'reifiable set constraint', :shared => true do
-  it 'should not accept strength option' do
-    lambda do 
-      @invoke_options.call(:strength => :default)
-    end.should raise_error(ArgumentError)
-  end
-  
-  it 'should accept reification option' do
-    bool = @model.bool_var
-    @expect_options.call(nil, bool)
-    @invoke_options.call(:reify => bool)
-  end
+  it_should_behave_like 'set constraint'
+  it_should_behave_like 'constraint with reification option'
 end
 
 # Help methods for the GecodeR specs. 
@@ -177,4 +244,21 @@ module GecodeR::Specs
       end
     end
   end
-end
+end
+
+# Helper for creating @expect_option. Creates a method which takes a hash that
+# may have values for the keys :icl (ICL_*), :pk (PK_*), and :bool (reification 
+# variable). Expectations corresponding to the hash values are given to the 
+# specified block in the order of icl, pk and bool. Default values are provided 
+# if the hash doesn't specify anything else.
+def option_expectation(&block)
+  lambda do |hash|
+    bool = hash[:bool]
+    # We loosen the expectation some to avoid practical problems with expecting
+    # specific variables not under our control.
+    bool = an_instance_of(Gecode::Raw::BoolVar) unless bool.nil?
+    yield(hash[:icl] || Gecode::Raw::ICL_DEF,
+      hash[:pk]  || Gecode::Raw::PK_DEF,
+      bool)
+  end
+end