gecoder-with-gecode 0.9.0-x86-mswin32-60

data/specs/constraints/int_enum/sort.rb

@@ -0,0 +1,167 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class SortSampleProblem < Gecode::Model
+  attr :vars
+  attr :sorted
+  attr :indices
+  
+  def initialize
+    @vars = int_var_array(4, 10..19)
+    @sorted = int_var_array(4, 10..19)
+    @indices = int_var_array(4, 0..9)
+    
+    # To make it more interesting
+    @vars.must_be.distinct
+    
+    branch_on @vars
+  end
+end
+
+describe Gecode::IntEnum::Sort, ' (without :as and :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.sorted(hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:rel).exactly(var.size - 1).times.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar), *opts)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), anything, 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          anything, anything, anything)
+        Gecode::Raw.should_receive(:rel).exactly(var.size - 1).times.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar),
+          an_instance_of(Gecode::Raw::BoolVar), *opts)
+      end
+    end
+  end
+  
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted
+    values = @model.solve!.vars.values
+    values.should == values.sort
+  end
+  
+  it 'should allow negation' do
+    @vars.must_not_be.sorted
+    @model.solve!
+    values = @vars.values
+    values.should_not == values.sort
+  end
+  
+  it_should_behave_like 'reifiable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :as)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.sorted hash.update(:as => int_enum)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted(:as => @sorted)
+    @model.solve!
+    values = @sorted.values
+    values.should == values.sort
+  end
+   
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    @indices = @model.indices
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.sorted hash.update(:order => int_enum)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, an_instance_of(Gecode::Raw::IntVarArray), var2,
+        *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted with the specified indices' do
+    @vars.must_be.sorted(:order => @indices)
+    @model.solve!
+    sorted_values = @vars.values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.value) }
+    @indices.values.should == expected_indices
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :order and :as)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    @indices = @model.indices
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum1, int_enum2, hash| 
+      receiver.sorted hash.update(:as => int_enum1, :order => int_enum2)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, var3, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, var3, *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted with the specified indices' do
+    @vars.must_be.sorted(:as => @sorted, :order => @indices)
+    @model.solve!
+    sorted_values = @sorted.values
+    sorted_values.should == sorted_values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.value) }
+    @indices.values.should == expected_indices
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/operands.rb

@@ -0,0 +1,264 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'operand', :shared => true do
+  it 'should not shadow method missing' do
+    lambda do
+      @operand.does_not_exist
+    end.should raise_error(NoMethodError)
+  end
+end
+
+describe 'variable operand', :shared => true do
+  it 'should fall back to the underlying variable' do
+    lambda do 
+      @operand.assigned?
+    end.should_not raise_error
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe 'enum operand', :shared => true do
+  it 'should fall back to the underlying enum' do
+    lambda do 
+      @operand[0]
+    end.should_not raise_error
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::Operand do
+  before do
+    model = Gecode::Model.new
+    @operand = Object.new
+    class <<@operand
+      include Gecode::Operand
+    end
+  end
+
+  it 'should raise error if #model is not defined' do
+    lambda do
+      @operand.model
+    end.should raise_error(NotImplementedError)
+  end
+
+  it 'should raise error if #construct_receiver is not defined' do
+    lambda do
+      @operand.must
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Int::IntOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_int_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Int::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Int::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_int_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Int::ShortCircuitRelationsOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Int::ShortCircuitRelationsOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_int_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::IntEnum::IntEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_int_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::Bool::BoolOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_bool_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Bool::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Bool::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_bool_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::BoolEnum::BoolEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_bool_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::Set::SetOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_set_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Set::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Set::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_set_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Set::ShortCircuitRelationsOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Set::ShortCircuitRelationsOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_set_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::SelectedSet::SelectedSetOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, ops = general_selected_set_operand(model)
+    @enum, @set = ops
+  end
+
+  it 'should raise error if set enum operand is not given' do
+    lambda do
+      Gecode::SelectedSet::SelectedSetOperand.new(:foo, @set)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if set operand is not given' do
+    lambda do
+      Gecode::SelectedSet::SelectedSetOperand.new(@enum, :foo)
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::SetElements::SetElementsOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, @set = general_set_elements_operand(model)
+  end
+
+  it 'should raise error if set operand is not given' do
+    lambda do
+      Gecode::SetElements::SetElementsOperand.new(:foo)
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::SetEnum::SetEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_set_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::FixnumEnum::FixnumEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_fixnum_enum_operand(model)
+  end
+
+  it 'should raise error if constraint receiver is called' do
+    lambda do
+      @operand.must
+    end.should raise_error(NotImplementedError)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+# High level sanity check.
+describe 'operand combination' do
+  it 'should allow placing constraints on complicated combinations of operands' do
+    model = Gecode::Model.new
+    sets = model.set_var_array(2, [], 0..9)
+    set1, set2 = sets
+    (set1.size + set2.size).must == 5
+    set1.size.must > 1
+    set2.size.must > 1
+    model.branch_on sets
+
+    model.solve!
+
+    (set1.value.size + set2.value.size).should == 5
+    set1.value.size.should > 1
+    set2.value.size.should > 1
+  end
+
+  it 'should allow placing constraints on complicated combinations of operands (2)' do
+    model = Gecode::Model.new
+    sets = model.set_var_array(3, [], 0..9)
+    set1, set2, set3 = sets
+    (set1.size + set2.size).must == (set3.size - set1.max)
+    set3.size.must > 3
+    set2.size.must < 3
+    set1.size.must > 0
+    model.branch_on sets
+
+    model.solve!
+
+    (set1.value.size + set2.value.size).should == (set3.value.size - set1.value.max)
+    set3.value.size.should > 3
+    set2.value.size.should < 3
+    set1.value.size.should > 0
+  end
+end

data/specs/constraints/property_helper.rb

@@ -0,0 +1,443 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Every property should have a spec that specs the following:
+#
+# * An example where the property is used to constrain a sample problem.
+# * should_behave_like foo operand
+# * A test that the property is translated to the correct Gecode
+# constraint if deemed necessary.
+
+# Several of these shared specs requires one or more of the following instance 
+# variables to be used: 
+# [@operand]  The operand that is being tested.
+# [@model]    The model that defines the context in which the test is
+#             conducted.
+# [@property_types]  An array of symbols signaling what types of
+#                    arguments @select_property accepts. The symbols
+#                    must be one of: :int, :bool, :set, :int_enum,
+#                    :bool_enum, :set_enum, :fixnum_enum.
+# [@select_property] A proc that selects the property under test. It
+#                    should take at least one argument: the operand that
+#                    the property should be selected from.
+# [@selected_property] The resulting operand of the property. It should
+#                      be constrained to the degree that it has a
+#                      non-maximal domain.
+# [@constraint_class] The class of the constraints that are expected to be
+#                     produced when a constraint is short circuited.
+#
+
+
+# Requires @operand and @model.
+describe 'int var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_int_var' do
+    int_var = @operand.to_int_var
+    int_var.should be_kind_of(Gecode::IntVar)
+    @model.solve!
+    (int_var.min..int_var.max).should_not equal(Gecode::Model::LARGEST_INT_DOMAIN)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Int::IntConstraintReceiver)
+  end
+end
+
+# Requires @operand and @model.
+describe 'bool var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_bool_var' do
+    bool_var = @operand.to_bool_var
+    bool_var.should be_kind_of(Gecode::BoolVar)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Bool::BoolConstraintReceiver)
+  end
+end
+
+# Requires @operand and @model.
+describe 'set var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_set_var' do
+    set_var = @operand.to_set_var
+    set_var.should be_kind_of(Gecode::SetVar)
+    @model.solve!
+    ((set_var.lower_bound == []) && 
+     (set_var.upper_bound == Gecode::Model::LARGEST_SET_BOUND)).should_not(
+      be_true)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Set::SetConstraintReceiver)
+  end
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces operand', :shared => true do
+  it 'should raise errors if parameters of the incorrect type are given' do
+    operands, variables = produce_general_arguments(@property_types)
+    (1...operands.size).each do |i|
+      bogus_operands = operands.clone
+      bogus_operands[i] = Object.new
+      lambda do
+        @select_property.call(*bogus_operands)
+      end.should raise_error(TypeError)
+    end
+  end
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces int operand', :shared => true do
+  it 'should produce int operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for int var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    int_var = operand.to_int_var
+    int_var.should be_kind_of(Gecode::IntVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Int::IntConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces bool operand', :shared => true do
+  it 'should produce bool operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for bool var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    bool_var = operand.to_bool_var
+    bool_var.should be_kind_of(Gecode::BoolVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Bool::BoolConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces set operand', :shared => true do
+  it 'should produce set operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for int var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    set_var = operand.to_set_var
+    set_var.should be_kind_of(Gecode::SetVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Set::SetConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is an int operand.
+describe 'property that produces int operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    int_operand = @selected_property
+    direct_int_var = int_operand.to_int_var
+    indirect_int_op, _ = general_int_operand(@model)
+    @selected_property.must == indirect_int_op
+    @model.solve!
+
+    direct_int_var.should_not have_domain(Gecode::Model::LARGEST_INT_DOMAIN)
+    direct_int_var.should have_domain(indirect_int_op.domain)
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.int_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.int_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    @selected_property.must.equal(@model.int_var, 
+      :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when the right hand side is not a operand' do
+    @selected_property.must.equal(2).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must > @model.int_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces int operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is a bool operand.
+describe 'property that produces bool operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    bool_operand = @selected_property
+    direct_bool_var = bool_operand.to_bool_var
+    indirect_bool_var = @model.bool_var
+    @selected_property.must == indirect_bool_var
+    @model.solve!
+
+    direct_bool_var.value.should == indirect_bool_var.value
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.bool_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.bool_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    @selected_property.must.equal(@model.bool_var, 
+      :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must.imply @model.bool_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces bool operand'
+end
+
+# Requires @model, @constraint_class, @property_types and @select_property.
+# 
+# These properties should short circuit all comparison relations
+# even when negated and when fixnums are used as right hand side.
+describe 'property that produces int operand by short circuiting relations', :shared => true do
+  it 'should produce reifiable constraints when short circuited' do
+    @constraint_class.superclass.should == 
+      Gecode::ReifiableConstraint
+  end
+
+  Gecode::Util::RELATION_TYPES.keys.each do |relation|
+    it "should give the same solution regardless of whether short circuit #{relation} was used" do
+      direct_int_var = @model.int_var
+      @selected_property.to_int_var.must.method(relation).call direct_int_var
+      indirect_int_var = @model.int_var
+      @selected_property.must.method(relation).call indirect_int_var
+      @model.solve!
+
+      direct_int_var.should_not have_domain(Gecode::Model::LARGEST_INT_DOMAIN)
+      direct_int_var.should have_domain(indirect_int_var.domain)
+    end
+
+    it "should short circuit #{relation}" do
+      (@selected_property.must.method(relation).call @model.int_var).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit negated #{relation}" do
+      (@selected_property.must_not.method(relation).call @model.int_var).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} when reification is used" do
+      (@selected_property.must.method(relation).call(@model.int_var, 
+        :reify => @model.bool_var)).should(be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} even when the right hand side is a fixnum" do
+      (@selected_property.must.method(relation).call 2).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should raise error when the #{relation} right hand side is of illegal type" do
+      lambda do
+        @selected_property.must.method(relation).call('foo')
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it_should_behave_like 'property that produces int operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is a set operand.
+describe 'property that produces set operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    set_operand = @selected_property
+    direct_set_var = set_operand.to_set_var
+    indirect_set_var = @model.set_var
+    @selected_property.must == indirect_set_var
+    @model.solve!
+
+    direct_set_var.should have_bounds(indirect_set_var.lower_bound, 
+      indirect_set_var.upper_bound)
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.set_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.set_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    (@selected_property.must.equal(@model.set_var, 
+      :reify => @model.bool_var)).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when the right hand side is not a operand' do
+    (@selected_property.must == [1,3,5]).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must_be.subset_of(@model.set_var)).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces set operand'
+end
+
+# Requires @model, @constraint_class, @property_types and @select_property.
+# 
+# These properties should only short circuit set relations when neither
+# negation nor reification is used (both for constant sets and set
+# variables). 
+describe 'property that produces set operand by short circuiting set relations', :shared => true do
+  Gecode::Util::SET_RELATION_TYPES.keys.each do |relation|
+    it 'should produce constraints when short circuited' do
+      @constraint_class.superclass.should == Gecode::Constraint
+    end
+
+    it "should give the same solution regardless of whether short circuit #{relation} was used" do
+      if relation == :complement
+        direct_set_var, indirect_set_var = Array.new(2){ @model.set_var }
+      else
+        direct_set_var, indirect_set_var = Array.new(2) do
+          @model.set_var([], -1000..1000)
+        end
+      end
+
+      @selected_property.to_set_var.must.method(relation).call direct_set_var
+      @selected_property.must.method(relation).call indirect_set_var
+      @model.solve!
+
+      if relation == :complement
+        direct_set_var.upper_bound.min.should == 
+          indirect_set_var.upper_bound.min
+        direct_set_var.upper_bound.max.should == 
+          indirect_set_var.upper_bound.max
+        direct_set_var.lower_bound.min.should ==
+          indirect_set_var.lower_bound.min
+        direct_set_var.lower_bound.max.should == 
+          indirect_set_var.lower_bound.max
+        direct_set_var.lower_bound.size.should == 
+          indirect_set_var.lower_bound.size
+      else
+        direct_set_var.should have_bounds(indirect_set_var.lower_bound, 
+          indirect_set_var.upper_bound)
+      end
+    end
+
+    it "should short circuit #{relation}" do
+      @selected_property.must.method(relation).call(@model.set_var).should( 
+        be_kind_of(@constraint_class))
+    end
+
+    it "should not short circuit negated #{relation}" do
+      @selected_property.must_not.method(relation).call(
+        @model.set_var).should_not(be_kind_of(@constraint_class))
+    end
+    
+    it "should not short circuit reified #{relation}" do
+      @selected_property.must.method(relation).call(@model.set_var, 
+        :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} even when the right hand side is a constant set" do
+      @selected_property.must.method(relation).call([1, 2, 3]).should( 
+        be_kind_of(@constraint_class))
+    end
+
+    it "should raise error when the #{relation} right hand side is of illegal type" do
+      lambda do
+        @selected_property.must.method(relation).call('foo')
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it_should_behave_like 'property that produces set operand'
+end