gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/connection.rb

@@ -1,369 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-# Requires @expect, @model, @stub, @target.
-describe 'connection constraint', :shared => true do
-  before do
-    @invoke = lambda do |rhs| 
-      @stub.must == rhs 
-      @model.solve!
-    end
-    
-    # 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, Gecode::Raw::PK_DEF,
-        nil, negated)
-    end
-    
-    # For options spec.
-    @invoke_options = lambda do |hash|
-      @stub.must_be.less_than_or_equal_to(17, hash)
-      @model.solve!
-    end
-    @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 'reifiable constraint'
-  it_should_behave_like 'composite constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (min)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 0..9)
-    @target = @var = @model.int_var(0..10)
-    @model.branch_on @model.wrap_enum([@set])
-    @stub = @set.min
-    
-    @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:min).once.with( 
-              an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::SetVar), rhs)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:min).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::SetVar), 
-              an_instance_of(Gecode::Raw::IntVar))
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:min).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the min of a set' do
-    @set.min.must == 3
-    @model.solve!
-    @set.lower_bound.min.should == 3
-  end
-  
-  it_should_behave_like 'connection constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (max)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 0..9)
-    @target = @var = @model.int_var(0..10)
-    @model.branch_on @model.wrap_enum([@set])
-    @stub = @set.max
-    
-    @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:max).once.with( 
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::SetVar), rhs)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:max).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::SetVar), 
-              an_instance_of(Gecode::Raw::IntVar))
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:max).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the max of a set' do
-    @set.max.must == 3
-    @model.solve!
-    @set.lower_bound.max.should == 3
-  end
-  
-  it_should_behave_like 'connection constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (sum)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 0..9)
-    @target = @var = @model.int_var(0..20)
-    @model.branch_on @model.wrap_enum([@set])
-    @stub = @set.sum
-    
-    @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), 
-              rhs)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), 
-              an_instance_of(Gecode::Raw::IntVar))
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:weights).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the sum of a set' do
-    @set.sum.must == 7
-    @model.solve!.should_not be_nil
-    @set.value.inject(0){ |x, y| x + y }.should == 7
-  end
-  
-  it 'should raise error if unsupported options is given' do
-    lambda do
-      @set.sum(:does_not_exist => :foo).must == @var 
-    end.should raise_error(ArgumentError)
-  end
-  
-  it 'should raise error if multiple options are given' do
-    lambda do
-      @set.sum(:weights => {}, :substitutions => {}).must == @var 
-    end.should raise_error(ArgumentError)
-  end
-  
-  it_should_behave_like 'connection constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 0..9)
-    @target = @var = @model.int_var(-20..20)
-    @model.branch_on @model.wrap_enum([@set])
-    @weights = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
-    @stub = @set.sum(:weights => @weights)
-    
-    @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), rhs)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), 
-              an_instance_of(Gecode::Raw::IntVar))
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:weights).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the sum of a set' do
-    @stub.must_be.in(-10..-1)
-    @model.solve!.should_not be_nil
-    weighted_sum = @set.value.inject(0){ |sum, x| sum - x**2 }
-    weighted_sum.should >= -10
-    weighted_sum.should <= -1
-  end
-  
-  it 'should remove any elements not in the weight hash' do
-    @set.sum(:weights => {}).must_be == 0
-    @model.solve!.should_not be_nil
-    @set.value.size.should be_zero
-  end
-  
-  it_should_behave_like 'connection constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 0..9)
-    @target = @var = @model.int_var(-20..20)
-    @model.branch_on @model.wrap_enum([@set])
-    @subs = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
-    @stub = @set.sum(:substitutions => @subs)
-    
-    @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), rhs)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, 
-              an_instance_of(Gecode::Raw::SetVar), 
-              an_instance_of(Gecode::Raw::IntVar))
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-              strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:weights).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should constrain the sum of a set' do
-    @stub.must_be.in(-10..-1)
-    @model.solve!.should_not be_nil
-    substituted_sum = @set.value.inject{ |sum, x| sum + @subs[x] }
-    substituted_sum.should >= -10
-    substituted_sum.should <= -1
-  end
-  
-  it_should_behave_like 'connection constraint'
-end
-
-describe Gecode::Constraints::Set::Connection, ' (include)' do
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([], 2..5)
-    @array = @model.int_var_array(4, 0..9)
-    @array.must_be.distinct
-    @model.branch_on @array
-    #@model.branch_on @model.wrap_enum([@set])
-    
-    @expect = lambda do |rhs, strength, reif_var|
-      @model.allow_space_access do
-        Gecode::Raw.should_receive(:match).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::SetVar), 
-          an_instance_of(Gecode::Raw::IntVarArray))
-      end
-    end
-    
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(@array, strength, reif_var)
-    end
-    @invoke_options = lambda do |hash|
-      @set.must.include(@array, hash)
-      @model.solve!
-    end
-  end
-  
-  it 'should translate to a match constraint' do
-    @expect_options.call({})
-    @set.must.include @array
-    @model.solve!
-  end
-  
-  it 'should constrain the variables to be included in the set' do
-    @set.must.include @array
-    @model.solve!.should_not be_nil
-    @array.all?{ |x| @set.lower_bound.include? x.value }.should be_true
-  end
-  
-  it 'should raise error if the right hand side is not an array of variables' do
-    lambda{ @set.must.include 'hello' }.should raise_error(TypeError)
-  end
-  
-  it 'should raise error if negated' do
-    lambda{ @set.must_not.include @array }.should raise_error(
-      Gecode::MissingConstraintError)
-  end
-  
-  it_should_behave_like 'non-reifiable set constraint'
-end

data/specs/constraints/count.rb

@@ -1,146 +0,0 @@
-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, kind, reif_var|
-      @model.allow_space_access do
-        target = an_instance_of(Gecode::Raw::IntVar) if target.respond_to? :bind
-        element = an_instance_of(Gecode::Raw::IntVar) if element.respond_to? :bind
-        if reif_var.nil?
-          Gecode::Raw.should_receive(:count).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            element, relation, target, strength, kind)
-        else
-          Gecode::Raw.should_receive(:count).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            element, Gecode::Raw::IRT_EQ,
-            an_instance_of(Gecode::Raw::IntVar), strength, kind)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation,
-            target, an_instance_of(Gecode::Raw::BoolVar), strength, kind)
-        end
-      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 = option_expectation do |strength, kind, reif_var|
-      @expect.call(@element, Gecode::Raw::IRT_GR, @target, strength, 
-        kind, reif_var)
-    end
-  end
-
-  # Various situations that must be handled (4*2 in total). This was originally
-  # written without the repetition (r269), but that interfered with the spec 
-  # somehow.
-
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable element and target" do
-      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF,
-        Gecode::Raw::PK_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 variable element and target" do
-      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil)
-      @list.count(@element).must_not.send(relation, @target)
-      @model.solve!
-    end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable element and constant target" do
-      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil)
-      @list.count(@element).must.send(relation, 2)
-      @model.solve!
-    end
-  end
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable element and constant target" do
-      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil)
-      @list.count(@element).must_not.send(relation, 2)
-      @model.solve!
-    end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant element and constant target" do
-      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF, nil)
-      @list.count(1).must.send(relation, 2)
-      @model.solve!
-    end
-  end
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with constant element and constant target" do
-      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF, nil)
-      @list.count(1).must_not.send(relation, 2)
-      @model.solve!
-    end
-  end
-
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant element and variable target" do
-      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil)
-      @list.count(1).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 constant element and variable target" do
-      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil)
-      @list.count(1).must_not.send(relation, @target)
-      @model.solve!
-    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 'reifiable constraint'
-end

data/specs/constraints/distinct.rb

@@ -1,164 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-class DistinctSampleProblem < Gecode::Model
-  attr :vars
-  attr :sets
-  
-  def initialize
-    @vars = int_var_array(2, 1)
-    @sets = set_var_array(2, [], 0..2)
-    branch_on @sets
-  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 = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:distinct).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
-    end
-  end
-
-  it 'should translate into a distinct constraint' do
-    Gecode::Raw.should_receive(:distinct).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_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 'non-reifiable constraint'
-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 = option_expectation do |strength, kind, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:distinct).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          anything, an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
-      else
-        Gecode::Raw.should_receive(:distinct).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          anything, an_instance_of(Gecode::Raw::IntVarArray), 
-          strength, kind, reif_var)
-      end
-    end
-  end
-
-  it 'should translate into a distinct constraint with offsets' do
-    Gecode::Raw.should_receive(:distinct).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      anything, anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_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.value.should equal(1)
-    y.value.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.value.should equal(1)
-    y.value.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 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Distinct, ' (at most one)' do
-  before do
-    @model = DistinctSampleProblem.new
-    @sets = @model.sets
-    @size = 2
-    
-    @invoke_options = lambda do |hash| 
-      @sets.must.at_most_share_one_element hash.update(:size => @size)
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:atmostOne).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::SetVarArray), @size)
-    end
-  end
-
-  it 'should translate into a atmostOne constraint' do
-    Gecode::Raw.should_receive(:atmostOne).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::SetVarArray), @size)
-    @sets.must.at_most_share_one_element(:size => @size)
-    @model.solve!
-  end
-
-  it 'should constrain sets to have at most one element in common' do
-    @sets.must.at_most_share_one_element(:size => @size)
-    @sets[0].must_not_be.superset_of 0
-    solution = @model.solve!
-    solution.should_not be_nil
-    set1, set2 = solution.sets
-    set1.value.size.should == @size
-    set2.value.size.should == @size
-    (set1.value.to_a & set2.value.to_a).size.should <= 1
-  end
-
-  it 'should not allow negation' do
-    lambda do
-      @sets.must_not.at_most_share_one_element(:size => @size) 
-    end.should raise_error(Gecode::MissingConstraintError)
-  end
-  
-  it 'should not allow options other than :size' do
-    lambda do
-      @sets.must.at_most_share_one_element(:size => @size, :foo => 17) 
-    end.should raise_error(ArgumentError)
-  end
-  
-  it 'should raise error if :size is not specified' do
-    lambda do
-      @sets.must.at_most_share_one_element 
-    end.should raise_error(ArgumentError)
-  end
-  
-  it_should_behave_like 'non-reifiable set constraint'
-end