gecoder 0.3.0 → 0.4.0

data/specs/constraints/arithmetic.rb

@@ -0,0 +1,227 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class ArithmeticSampleProblem < Gecode::Model
+  attr :numbers
+  attr :var
+  attr :var2
+  
+  def initialize
+    @numbers = int_var_array(4, 0..9)
+    @var = int_var(-9..9)
+    @var2 = int_var(0..9)
+    branch_on @numbers
+    branch_on wrap_enum([@var, @var2])
+  end
+end
+
+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
+    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!
+      end
+    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) 
+  end
+  
+  it_should_behave_like 'constraint with options'
+end
+
+describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @var = @model.var
+    @stub = @numbers.max
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, reif_var|
+      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)
+      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))
+        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
+    @numbers.max.must > 5
+    @model.solve!.numbers.map{ |n| n.val }.max.should > 5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @var = @model.var
+    @stub = @numbers.min
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, reif_var|
+      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)
+      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))
+        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
+    @numbers.min.must > 5
+    @model.solve!.numbers.map{ |n| n.val }.min.should > 5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @stub = @var.abs
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, reif_var|
+      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)
+      else
+        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, reif_var.bind,
+          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
+    @var.must < 0
+    @var.abs.must == 5
+    @model.solve!.var.val.should == -5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @var2 = @model.var2
+    @stub = @var * @var2
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, reif_var|
+      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)
+      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))
+        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
+    (@var * @var2).must == 56
+    sol = @model.solve!
+    [sol.var.val, sol.var2.val].sort.should == [7, 8]
+  end
+  
+  it 'should not interfere with other defined multiplication methods' do
+    (@var * :foo).should be_nil
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end

data/specs/constraints/boolean.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class BoolSampleProblem < Gecode::Model
+  attr :b1
+  attr :b2
+  attr :b3
+  
+  def initialize
+    @b1 = self.bool_var
+    @b2 = self.bool_var
+    @b3 = self.bool_var
+  end
+end
+
+describe Gecode::Constraints::Bool do
+  before do
+    @model = BoolSampleProblem.new
+    @b1 = @model.b1
+    @b2 = @model.b2
+    @b3 = @model.b3
+  end
+  
+  it 'should handle single variables constrainted to be true' do
+    @b1.must_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.true?.should be_true
+  end
+  
+  it 'should handle single variables constrainted to be false' do
+    @b1.must_be.false
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.true?.should_not be_true
+  end
+  
+  it 'should handle single variables constrainted not to be true' 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
+    @b1.must_not_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.true?.should_not be_true
+  end
+
+  it 'should handle disjunction' 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 disjunction' do
+    @b1.must_be.false
+    (@b1 | @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle conjunction' do
+    (@b1 & @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should be_true
+  end
+
+  it 'should handle negated conjunction' do
+    @b1.must_be.true
+    (@b1 & @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 single variables as right hand side' do
+    @b1.must == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle single variables with negation as right hand side' do
+    @b1.must_not == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should_not be_true
+  end
+  
+  it 'should handle expressions as right hand side' do
+    @b1.must == (@b2 | @b3)
+    @b2.must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should be_true
+  end
+  
+  it 'should handle nested expressions as left hand side' do
+    ((@b1 & @b2) | @b3 | (@b1 & @b3)).must_be.true
+    @b1.must_be.false
+    sol = @model.solve!
+    sol.b1.true?.should_not be_true
+    sol.b3.true?.should be_true
+  end
+  
+  it 'should handle nested expressions on both side' do
+    ((@b1 & @b1) | @b3).must == ((@b1 & @b3) & @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should be_true
+    sol.b3.true?.should 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
+    @b3.must_be.true
+    sol = @model.solve!
+    sol.b1.true?.should be_true
+    sol.b2.true?.should_not be_true
+    sol.b3.true?.should be_true
+  end
+end

data/specs/constraints/channel.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class ChannelSampleProblem < Gecode::Model
+  attr :elements
+  attr :positions
+  
+  def initialize
+    @elements = int_var_array(4, 0..3)
+    @elements.must_be.distinct
+    @positions = int_var_array(4, 0..3)
+    @positions.must_be.distinct
+    branch_on @elements
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Channel do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @elements = @model.elements
+    @invoke_options = lambda do |hash| 
+      @positions.must.channel @elements, hash
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVarArray), strength)
+    end
+  end
+
+  it 'should translate into a channel constraint' do
+    Gecode::Raw.should_receive(:channel).once.with(@model.active_space, 
+      anything, anything, Gecode::Raw::ICL_DEF)
+    @invoke_options.call({})
+  end
+
+  it 'should constrain variables to be channelled' do
+    @elements.must.channel @positions
+    @model.solve!
+    elements = @model.elements.map{ |e| e.val }
+    positions = @model.elements.map{ |p| p.val }
+    elements.each_with_index do |element, i|
+      element.should equal(positions.index(i))
+    end
+  end
+
+  it 'should not allow negation' do
+    lambda{ @elements.must_not.channel @positions }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end

data/specs/constraints/constraint_helper.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# This requires that the constraint spec has instance variables @invoke_options
+# and @expect_options .
+describe 'constraint with strength option', :shared => true do
+  { :default  => Gecode::Raw::ICL_DEF,
+    :value    => Gecode::Raw::ICL_VAL,
+    :bounds   => Gecode::Raw::ICL_BND,
+    :domain   => Gecode::Raw::ICL_DOM
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation strength #{name}" do
+      @expect_options.call(gecode_value, nil)
+      @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)
+    @invoke_options.call({})
+  end
+  
+  it 'should raise errors for unrecognized options' do
+    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
+      raise_error(ArgumentError))
+  end
+  
+  it 'should raise errors for unrecognized propagation strengths' do
+    lambda{ @invoke_options.call(:strength => :does_not_exist) }.should(
+      raise_error(ArgumentError))
+  end
+  
+  it 'should raise errors for reification variables of incorrect type' do
+    lambda{ @invoke_options.call(:reify => 'foo') }.should(
+      raise_error(TypeError))
+  end
+end
+
+# This requires that the constraint spec has instance variables @invoke_options
+# and @expect_options .
+describe 'constraint with options', :shared => true do
+  it 'should translate reification' do
+    var = @model.bool_var
+    @expect_options.call(Gecode::Raw::ICL_DEF, var)
+    @invoke_options.call(:reify => var)
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end

data/specs/constraints/constraints.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Gecode::Constraints::Expression do
+  it 'should raise error if it doesn\'t get all parameters for initialization' do
+    lambda do 
+      Gecode::Constraints::Expression.new(Gecode::Model.new, :negate => false) 
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Expression do
+  it 'should raise error unless lhs is an enum' do
+    lambda do
+      Gecode::Constraints::IntEnum::Expression.new(Gecode::Model.new, 
+        :lhs => 'foo', :negate => false)
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Constraints::Constraint, ' (not subclassed)' do
+  before do
+    @con = Gecode::Constraints::Constraint.new(Gecode::Model.new, {})
+  end
+
+  it 'should raise error when calling #post because it\'s not overridden' do
+    lambda{ @con.post }.should raise_error(NoMethodError)
+  end
+end

data/specs/constraints/count.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class CountSampleProblem < Gecode::Model
+  attr :list
+  attr :element
+  attr :target
+  
+  def initialize
+    @list = int_var_array(4, 0..3)
+    @element = int_var(0..3)
+    @target = int_var(0..4)
+    branch_on @list
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Count do
+  before do
+    @model = CountSampleProblem.new
+    @list = @model.list
+    @element = @model.element
+    @target = @model.target
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |element, relation, target, strength, reif_var|
+      target = target.bind if target.respond_to? :bind
+      element = element.bind if element.respond_to? :bind
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:count).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVarArray), 
+          element, relation, target, strength)
+      else
+        Gecode::Raw.should_receive(:count).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVarArray), 
+          element, Gecode::Raw::IRT_EQ,
+          an_instance_of(Gecode::Raw::IntVar), strength)
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), relation,
+          target, reif_var.bind, strength)
+      end
+    end
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @list.count(@element).must_be.greater_than(@target, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@element, Gecode::Raw::IRT_GR, @target, strength, reif_var)
+    end
+  end
+
+  # Various situations that must be handled, nil denotes that a variable should
+  # be used.
+  situations = {
+    'variable element and target' => [nil, nil],
+    'variable element and constant target' => [nil, 2],
+    'constant element and variable target' => [1, nil],
+    'constant element and constant target' => [1, 2]
+  }.each_pair do |description, element_and_target|
+    element, target = element_and_target
+    Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+      it "should translate #{relation} with #{description}" do
+        element = @element if element.nil?
+        target = @target if target.nil?
+        @expect.call(element, type, target, Gecode::Raw::ICL_DEF, nil)
+        @list.count(element).must.send(relation, target)
+        @model.solve!
+      end
+    end
+    Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+      it "should translate negated #{relation} with #{description}" do
+        element = @element if element.nil?
+        target = @target if target.nil?
+        @expect.call(element, type, target, Gecode::Raw::ICL_DEF, nil)
+        @list.count(element).must_not.send(relation, target)
+        @model.solve!
+      end
+    end
+  end
+
+  it 'should raise error if the target is of the wrong type' do
+    lambda{ @list.count(@element).must == 'hello' }.should raise_error(
+      TypeError) 
+  end
+  
+  it 'should raise error on element is of the wrong type' do
+    lambda{ @list.count('foo').must == @target }.should raise_error(
+      TypeError)
+  end
+  
+  it 'should constrain the count' do
+    @list.must_be.distinct
+    @list.count(0).must <= 0
+    @model.solve!.should be_nil
+  end
+  
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/distinct.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class DistinctSampleProblem < Gecode::Model
+  attr :vars
+  
+  def initialize
+    @vars = int_var_array(2, 1)
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Distinct do
+  before do
+    @model = DistinctSampleProblem.new
+    @invoke_options = lambda do |hash| 
+      @model.vars.must_be.distinct(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), strength)
+    end
+  end
+
+  it 'should translate into a distinct constraint' do
+    Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+      anything, Gecode::Raw::ICL_DEF)
+    @invoke_options.call({})
+  end
+
+  it 'should constrain variables to be distinct' do
+    # This won't work well without branching or propagation strengths. So this
+    # just shows that the distinct constraint will cause trivially unsolvable
+    # problems to directly fail.
+    @model.vars.must_be.distinct
+    @model.solve!.should be_nil
+  end
+
+  it 'should not allow negation' do
+    lambda{ @model.vars.must_not_be.distinct }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end
+
+describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
+  before do
+    @model = DistinctSampleProblem.new
+    @invoke_options = lambda do |hash| 
+      @model.vars.with_offsets(1,2).must_be.distinct(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+          anything, an_instance_of(Gecode::Raw::IntVarArray), strength)
+      else
+        Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+          anything, an_instance_of(Gecode::Raw::IntVarArray), strength,
+          an_instance_of(Gecode::Raw::BoolVar))
+      end
+    end
+  end
+
+  it 'should translate into a distinct constraint with offsets' do
+    Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+      anything, anything, Gecode::Raw::ICL_DEF)
+    @invoke_options.call({})
+  end
+
+  it 'should consider offsets when making variables distinct' do
+    @model.vars.with_offsets(-1,0).must_be.distinct
+    x,y = @model.solve!.vars
+    x.val.should equal(1)
+    y.val.should equal(1)
+  end
+  
+  # This tests two distinct in conjunction. It's here because of a bug found.
+  it 'should play nice with normal distinct' do
+    @model.vars.with_offsets(-1,0).must_be.distinct
+    @model.vars.must_be.distinct
+    @model.solve!.should be_nil
+  end
+  
+  it 'should accept an array as offsets' do
+    @model.vars.with_offsets([-1,0]).must_be.distinct
+    x,y = @model.solve!.vars
+    x.val.should equal(1)
+    y.val.should equal(1)
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @model.vars.with_offsets(1,2).must_not_be.distinct }.should 
+      raise_error(Gecode::MissingConstraintError)
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end