gecoder 0.4.0 → 0.5.0

data/specs/constraints/arithmetic.rb

@@ -5,43 +5,53 @@ class ArithmeticSampleProblem < Gecode::Model
   attr :numbers
   attr :var
   attr :var2
+  attr :var3
   
   def initialize
     @numbers = int_var_array(4, 0..9)
     @var = int_var(-9..9)
     @var2 = int_var(0..9)
+    @var3 = int_var(0..9)
     branch_on @numbers
-    branch_on wrap_enum([@var, @var2])
+    branch_on wrap_enum([@var, @var2, @var3])
   end
 end
 
+# Requires @stub, @target, @model and @expect.
 describe 'arithmetic constraint', :shared => true do
-  situations = {
-    'variable bound' => nil,
-    'constant bound' => 5
-  }.each_pair do |description, bound|
-    Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-      it "should translate #{relation} with #{description}" do
-        bound = @var if bound.nil?
-        @expect.call(type, bound, Gecode::Raw::ICL_DEF, nil)
-        @stub.must.send(relation, bound)
-        @model.solve!
-      end
+  before do
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @stub.must_be.greater_than(@target, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::IRT_GR, @target, strength, reif_var, false)
     end
-    Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-      it "should translate negated #{relation} with #{description}" do
-        bound = @var if bound.nil?
-        @expect.call(type, bound, Gecode::Raw::ICL_DEF, nil)
-        @stub.must_not.send(relation, bound)
-        @model.solve!
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @stub.must_not.send(relation, target)
+      else
+        @stub.must.send(relation, target)
       end
+      @model.solve!
+    end
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
     end
   end
   
-  it 'should raise error if the right hand side is of the wrong type' do
-    lambda{ @stub.must == 'hello' }.should raise_error(TypeError) 
+  it 'should translate reification when using equality' do
+    bool_var = @model.bool_var
+    @expect.call(Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, bool_var, 
+      false)
+    @stub.must_be.equal_to(@target, :reify => bool_var)
+    @model.solve!
   end
   
+  it_should_behave_like 'composite constraint'
   it_should_behave_like 'constraint with options'
 end
 
@@ -49,36 +59,34 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
   before do
     @model = ArithmeticSampleProblem.new
     @numbers = @model.numbers
-    @var = @model.var
+    @target = @var = @model.var
     @stub = @numbers.max
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var|
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
       rhs = rhs.bind if rhs.respond_to? :bind
       if reif_var.nil?
-        Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            rhs.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        end
       else
         Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+          an_instance_of(Gecode::Raw::IntVar), strength)
         Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
           strength)
       end
     end
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @numbers.max.must_be.greater_than(@var, hash) 
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @var, strength, reif_var)
-    end
   end
   
   it 'should constrain the maximum value' do
@@ -93,36 +101,34 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
   before do
     @model = ArithmeticSampleProblem.new
     @numbers = @model.numbers
-    @var = @model.var
+    @target = @var = @model.var
     @stub = @numbers.min
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var|
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
       rhs = rhs.bind if rhs.respond_to? :bind
       if reif_var.nil?
-        Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            rhs.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        end
       else
         Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+          an_instance_of(Gecode::Raw::IntVar), strength)
         Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
           strength)
       end
     end
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @numbers.min.must_be.greater_than(@var, hash) 
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @var, strength, reif_var)
-    end
   end
   
   it 'should constrain the minimum value' do
@@ -137,35 +143,32 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
   before do
     @model = ArithmeticSampleProblem.new
     @var = @model.var
+    @target = @model.var2
     @stub = @var.abs
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var|
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
       rhs = rhs.bind if rhs.respond_to? :bind
       if reif_var.nil?
-        Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
-          @var.bind, an_instance_of(Gecode::Raw::IntVar), 
-          an_instance_of(Fixnum))
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            rhs.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
+            @var.bind, rhs, strength)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
+            @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
+          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        end
       else
         Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
-          @var.bind, an_instance_of(Gecode::Raw::IntVar), 
-          an_instance_of(Fixnum))
+          @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
         Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
-          strength)
+          an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
       end
     end
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @var.abs.must_be.greater_than(@var, hash) 
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @var, strength, reif_var)
-    end
   end
   
   it 'should constrain the absolute value' do
@@ -183,34 +186,32 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
     @var = @model.var
     @var2 = @model.var2
     @stub = @var * @var2
+    @target = @model.var3
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var|
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
       rhs = rhs.bind if rhs.respond_to? :bind
       if reif_var.nil?
-        Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
-          @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), 
-          an_instance_of(Fixnum))
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            rhs.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
+            @var.bind, @var2.bind, rhs, strength)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
+            @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), 
+            strength)
+          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+        end
       else
         Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
-          @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), 
-          an_instance_of(Fixnum))
+          @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), strength)
         Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
           strength)
       end
     end
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      (@var * @var2).must_be.greater_than(@var, hash) 
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @var, strength, reif_var)
-    end
   end
   
   it 'should constrain the value of the multiplication' do

data/specs/constraints/bool_enum.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class BoolEnumSampleProblem < Gecode::Model
+  attr :bools
+  attr :b1
+  attr :b2
+  
+  def initialize
+    @bools = bool_var_array(4)
+    @b1 = bool_var
+    @b2 = bool_var
+    branch_on @bools
+    branch_on wrap_enum([@b1, @b2])
+  end
+end
+
+# Expects @stub, which contains the started constraint and @compute_result which 
+# computes whether the left hand side is true or not.
+describe 'bool enum constraint', :shared => true do
+  it 'should handle being constrained to be true' do
+    @stub.must_be.true
+    @model.solve!
+    @compute_result.call.should be_true
+  end
+  
+  it 'should handle being constrained to be negated true' do
+    @stub.must_not_be.true
+    @model.solve!
+    @compute_result.call.should_not be_true
+  end
+  
+  it 'should handle being constrained to be false' do
+    @stub.must_be.false
+    @model.solve!
+    @compute_result.call.should_not be_true
+  end
+  
+  it 'should handle being constrained to be negated false' do
+    @stub.must_not_be.false
+    @model.solve!
+    @compute_result.call.should be_true
+  end
+  
+  it 'should handle being constrained to be equal to a variable' do
+    @stub.must_be == @b1
+    @model.solve!
+    @compute_result.call.should == @b1.true?
+  end
+  
+  it 'should handle being constrained to not be equal to a variable' do
+    @stub.must_not_be == @b1
+    @model.solve!
+    @compute_result.call.should_not == @b1.true?
+  end
+  
+  it 'should handle being constrained to be equal to be a nested expression' do
+    @stub.must_be == (@b1 | @b2) & @b1
+    @model.solve!
+    @compute_result.call.should == (@b1.true? | @b2.true?) & @b1.true?
+  end
+  
+  it 'should handle being constrained to not be equal to be a nested expression' do
+    @stub.must_not_be == (@b1 | @b2) & @b1
+    @model.solve!
+    @compute_result.call.should_not == (@b1.true? | @b2.true?) & @b1.true?
+  end
+end
+
+describe Gecode::Constraints::BoolEnum, ' (conjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @bools.conjunction.must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:bool_and).once.with(@model.active_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(@model.active_space, 
+          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      end
+    end
+    
+    # For bool enum spec.
+    @stub = @bools.conjunction
+    @compute_result = lambda{ @bools.all?{ |b| b.true? } }
+  end
+  
+  it_should_behave_like 'bool enum constraint'
+  it_should_behave_like 'constraint with options'
+end
+
+describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @bools.disjunction.must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:bool_or).once.with(@model.active_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(@model.active_space, 
+          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      end
+    end
+    
+    # For bool enum spec.
+    @stub = @bools.disjunction
+    @compute_result = lambda{ @bools.any?{ |b| b.true? } }
+  end
+  
+  it_should_behave_like 'bool enum constraint'
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/boolean.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
 
 class BoolSampleProblem < Gecode::Model
   attr :b1
@@ -18,6 +19,21 @@ describe Gecode::Constraints::Bool do
     @b1 = @model.b1
     @b2 = @model.b2
     @b3 = @model.b3
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      (@b1 | @b2).must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:bool_or).once.with(@model.active_space, 
+        @b1.bind, @b2.bind, an_instance_of(Gecode::Raw::BoolVar), 
+        Gecode::Raw::ICL_DEF)
+      unless reif_var.nil?
+        Gecode::Raw.should_receive(:bool_eqv).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      end
+    end
   end
   
   it 'should handle single variables constrainted to be true' do
@@ -34,14 +50,14 @@ describe Gecode::Constraints::Bool do
     b1.true?.should_not be_true
   end
   
-  it 'should handle single variables constrainted not to be true' do
+  it 'should handle single variables constrainted not to be false' do
     @b1.must_not_be.false
     b1 = @model.solve!.b1
     b1.should be_assigned
     b1.true?.should be_true
   end
   
-  it 'should handle single variables constrainted not to be false' do
+  it 'should handle single variables constrainted not to be true' do
     @b1.must_not_be.true
     b1 = @model.solve!.b1
     b1.should be_assigned
@@ -79,6 +95,54 @@ describe Gecode::Constraints::Bool do
     sol.b2.true?.should_not be_true
   end
 
+  it 'should handle exclusive or' do
+    @b1.must_be.false
+    (@b1 ^ @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b2.true?.should be_true
+  end
+
+  it 'should handle negated exclusive or' do
+    @b1.must_be.true
+    (@b1 ^ @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should be_true
+  end
+  
+  it 'should handle implication' do
+    @b2.must_be.false
+    (@b1.implies @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle negated implication' do
+    @b1.must_be.true
+    ((@b1 | @b2).implies @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle imply after must' do
+    @b2.must_be.false
+    @b1.must.imply @b2
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle imply after must_not' do
+    @b1.must_be.true
+    @b1.must_not.imply @b2
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should_not be_true
+  end
+
   it 'should handle single variables as right hand side' do
     @b1.must == @b2
     @b2.must_be.false
@@ -120,6 +184,16 @@ describe Gecode::Constraints::Bool do
     sol.b3.true?.should be_true
   end
   
+  it 'should handle nested expressions containing exclusive or' do
+    ((@b1 ^ @b1) & @b3).must == ((@b2 | @b3) ^ @b2)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should_not be_true
+    sol.b3.true?.should_not be_true
+  end
+  
   it 'should handle nested expressions on both sides with negation' do
     ((@b1 & @b1) | @b3).must_not == ((@b1 | @b3) & @b2)
     @b1.must_be.true
@@ -129,4 +203,23 @@ describe Gecode::Constraints::Bool do
     sol.b2.true?.should_not be_true
     sol.b3.true?.should be_true
   end
+  
+  it 'should translate reification with a variable right hand side' do
+    @b1.must_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.true?.should_not be_true
+  end
+  
+  it 'should translate reification with a variable right hand side and negation' do
+    @b1.must_not_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.true?.should be_true
+  end
+  
+  
+  it_should_behave_like 'constraint with options'
 end

data/specs/constraints/cardinality.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Set::Cardinality, ' (range)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..10)
+    @model.branch_on @model.wrap_enum([@set])
+    @range = 1..2
+    @three_dot_range = 1...2
+    
+    @invoke_options = lambda do |hash| 
+      @set.size.must_be.in(@range, hash) 
+    end
+    
+    @invoke = lambda do |rhs| 
+      @set.size.must_be.in(rhs) 
+      @model.solve!
+    end
+    @expect = lambda do |rhs|
+      Gecode::Raw.should_receive(:cardinality).once.with(@model.active_space, 
+        @set.bind, rhs.first, rhs.last)
+    end
+  end
+  
+  it 'should translate cardinality constraints with ranges' do
+    @expect.call(@range)
+    @invoke.call(@range)
+  end
+
+  it 'should translate cardinality constraints with three dot range domains' do
+    @expect.call(@three_dot_range)
+    @invoke.call(@three_dot_range)
+  end
+  
+  it 'should constrain the cardinality of a set' do
+    @set.size.must_be.in @range
+    @model.solve!
+    @range.should include(@set.val_size)
+  end
+  
+  it 'should raise error if the right hand side is not a range' do
+    lambda{ @set.size.must_be.in 'hello' }.should raise_error(TypeError)
+  end
+  
+  it 'should not shadow the integer variable domain constrain' do
+    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+      an_instance_of(Gecode::Raw::IntVar), an_instance_of(Gecode::Raw::IntSet), 
+      Gecode::Raw::ICL_DEF)
+    @set.size.must_not_be.in [1,3]
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..10)
+    @target = @var = @model.int_var(0..11)
+    @model.branch_on @model.wrap_enum([@set])
+    @model.branch_on @model.wrap_enum([@var])
+    
+    @invoke_options = lambda do |hash| 
+      @set.size.must_be.equal_to(@var, hash) 
+    end
+    
+    @invoke = lambda do |rhs| 
+      @set.size.must == rhs 
+      @model.solve!
+    end
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      rhs = rhs.bind if rhs.respond_to? :bind
+      if reif_var.nil?
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            rhs.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:cardinality).once.with(
+            @model.active_space, @set.bind, rhs)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(:cardinality).once.with(
+            @model.active_space, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            strength)
+        end
+      else
+        Gecode::Raw.should_receive(:cardinality).once.with(@model.active_space, 
+          @set.bind, an_instance_of(Gecode::Raw::IntVar))
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+          strength)
+      end
+    end
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @set.size.must_not.send(relation, target)
+      else
+        @set.size.must.send(relation, target)
+      end
+      @model.solve!
+    end
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @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)
+    end
+  end
+  
+  it 'should constrain the cardinality of a set' do
+    @set.size.must == @var
+    @model.solve!
+    @set.val_size.should == @var.val
+  end
+  
+  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'composite constraint'
+end