gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/constraint_helper.rb

@@ -1,264 +1,234 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-# Several of these shared specs requires one or more of the following instance 
-# variables to be used: 
-# [@expect_options]  A method that creates an expectation on the aspect to be 
-#                    tested, using the provided hash of Gecode values. The hash 
-#                    can have values for the keys :icl (ICL_*), :pk (PK_*), and 
-#                    :bool (bound reification variable). Any values not 
-#                    provided are assumed to be default values (nil in the case 
-#                    of :bool).
-# [@invoke_options]  A method that invokes the aspect to be tested, with the 
-#                    provided hash of options (with at most the keys :strength, 
-#                    :kind and :reify).
+# Every constraint should have a spec that specs the following:
+#
+# * An example where the constraint is used to constrain a sample
+# problem (and one for negation if deemed necessary).
+# * should_behave_like [non-reifiable|reifiable] constraint (possibly
+# indirect).
+# * Those constraints that do not support negation must
+# should_behave_like 'non-negatable constraint'
+#
+
+
+# These specs assume that the following variables are defined:
+# [@expect]          A proc that creates an expectation corresponding to
+#                    constraint. It should take three parameter. The
+#                    first is an array of operands of types specified by
+#                    @types. The second is whether or not the constraint
+#                    should be negated. The third is a hash that can
+#                    have values for the keys :icl (ICL_*), :pk (PK_*),
+#                    and :bool (bound reification variable). Any values
+#                    not provided are assumed to be default values (nil
+#                    in the case of :bool).
+# [@invoke]          A proc that invokes the constraint to be tested, It 
+#                    should have arity arity(@types) + 1. The first
+#                    parameter is a constraint receiver (type decided by 
+#                    @types). The next arity(@types)-1 parameters are 
+#                    given operands of types specified by @types. The
+#                    last parameter is a hash of options (with at most
+#                    the keys :strength, :kind and :reify)..
+# [@types]           An array of symbols signaling what types of
+#                    arguments @ accepts. The symbols
+#                    must be one of: :int, :bool, :set, :int_enum,
+#                    :bool_enum, :set_enum, :fixnum_enum.
 # [@model]           The model instance that contains the aspects being tested.
-# [@expect_relation] A method that takes a relation, right hand side, and 
-#                    whether it's negated, as arguments and sets up the 
-#                    corresponding expectations. 
-# [@invoke_relation] A method that takes a relation, right hand side, and 
-#                    whether it's negated, as arguments and adds the 
-#                    corresponding constraint and invokes it.
-# [@target]          A legal right hand side that can be used as argument to 
-#                    the above two methods.
 
-
-# Requires @invoke_options and @expect_options.
-describe 'constraint with strength option', :shared => true do
-  { :default  => Gecode::Raw::ICL_DEF,
-    :value    => Gecode::Raw::ICL_VAL,
-    :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(:icl => gecode_value)
-      @invoke_options.call(:strength => name)
+def expect(variables, options)
+  bool = options[:bool]
+  bool = @model.allow_space_access{ bool.bind } unless bool.nil?
+  args = @model.allow_space_access do 
+    variables.map do |var| 
+      if var.respond_to? :bind
+        var.bind
+      else
+        var.bind_array
+      end
     end
   end
-  
-  it 'should default to using default as propagation strength' do
-    @expect_options.call({})
-    @invoke_options.call({})
+  args << [options[:icl] || Gecode::Raw::ICL_DEF,
+           options[:pk]  || Gecode::Raw::PK_DEF]
+  args << bool
+  @expect.call(*args)
+end
+
+def invoke(operands, options)
+  base_op = operands.first
+  if options.delete(:negate)
+    receiver = base_op.must_not
+  else
+    receiver = base_op.must
   end
-  
-  it 'should raise errors for unrecognized propagation strengths' do
+  args = ([receiver] + operands[1..-1]) << options
+  @invoke.call(*args)
+end
+
+describe 'reifiable constraint', :shared => true do
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint with reification option'
+  it_should_behave_like 'constraint'
+end
+
+describe 'non-reifiable constraint', :shared => true do
+  it 'should raise errors if reification is used' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:strength => :does_not_exist) 
+      invoke(operands, :reify => @model.bool_var)
     end.should raise_error(ArgumentError)
   end
+
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint'
 end
 
-# Requires @invoke_options and @expect_options.
-describe 'constraint with kind option', :shared => true do
-  { :default  => Gecode::Raw::PK_DEF,
-    :speed    => Gecode::Raw::PK_SPEED,
-    :memory   => Gecode::Raw::PK_MEMORY
-  }.each_pair do |name, gecode_value|
-    it "should translate propagation kind #{name}" do
-      @expect_options.call(:pk => gecode_value)
-      @invoke_options.call(:kind => name)
-    end
-  end
-  
-  it 'should default to using default as propagation kind' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  end
-  
-  it 'should raise errors for unrecognized propagation kinds' do
+describe 'non-negatable constraint', :shared => true do
+  it 'should raise errors if negation is used' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:kind => :does_not_exist)
-    end.should raise_error(ArgumentError)
+      invoke(operands, :negate => true)
+    end.should raise_error(Gecode::MissingConstraintError)
   end
 end
 
+describe 'constraint', :shared => true do
+  it 'should raise errors if parameters of the incorrect type are given' do
+    operands, variables = produce_general_arguments(@types)
+    (1...operands.size).each do |i|
+      bogus_operands = operands.clone
+      bogus_operands[i] = Object.new
+      lambda do
+        invoke(bogus_operands, {})
+      end.should raise_error(TypeError)
+    end
+  end
+end
 
-# Requires @invoke_options and @expect_options.
 describe 'constraint with reification option', :shared => true do
   it 'should translate reification' do
+    operands, variables = produce_general_arguments(@types)
     var = @model.bool_var
-    @expect_options.call(:bool => var)
-    @invoke_options.call(:reify => var)
+    expect(variables, :bool => var)
+    invoke(operands, :reify => var)
+  end
+
+  it 'should translate reification with arbitrary bool operand' do
+    operands, variables = produce_general_arguments(@types)
+    op, bool_var = general_bool_operand(@model)
+    expect(variables, :bool => bool_var)
+    invoke(operands, :reify => op)
   end
   
   it 'should raise errors for reification variables of incorrect type' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => 'foo')
+      invoke(operands, :reify => 'foo')
     end.should raise_error(TypeError)
   end
 end
 
-# Requires @invoke_options and @expect_options.
-describe 'reifiable constraint', :shared => true do
-  it_should_behave_like 'constraint with default options'
-  it_should_behave_like 'constraint with reification option'
-end
-
-# Requires @invoke_options, @expect_options and @model.
-describe 'non-reifiable constraint', :shared => true do
-  it 'should raise errors if reification is used' do
+describe 'constraint with default options', :shared => true do
+  it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => @model.bool_var)
+      invoke(operands, :does_not_exist => :foo) 
     end.should raise_error(ArgumentError)
   end
-  
-  it_should_behave_like 'constraint with default options'
-end
 
-# Requires @invoke_options and @expect_options.
-describe 'constraint with default options', :shared => true do
-  it 'should raise errors for unrecognized options' do
-    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
-      raise_error(ArgumentError))
-  end
-  
   it_should_behave_like 'constraint with strength option'
   it_should_behave_like 'constraint with kind option'
 end
 
-# Requires @expect_relation, @invoke_relation and @target.
-describe 'composite constraint', :shared => true do
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant target" do
-      @expect_relation.call(type, 1, false)
-      @invoke_relation.call(relation, 1, false)
-    end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable target" do
-      @expect_relation.call(type, @target, false)
-      @invoke_relation.call(relation, @target, false)
+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
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :icl => gecode_value)
+      invoke(operands, :strength => name)
     end
   end
   
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with constant target" do
-      @expect_relation.call(type, 1, true)
-      @invoke_relation.call(relation, 1, true)
-    end
+  it 'should default to using default as propagation strength' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
   end
   
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable target" do
-      @expect_relation.call(type, @target, true)
-      @invoke_relation.call(relation, @target, true)
-    end
-  end
-
-  it 'should raise error if the target is of the wrong type' do
+  it 'should raise errors for unrecognized propagation strengths' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_relation.call(:==, 'hello', false)
-    end.should raise_error(TypeError) 
+      invoke(operands, :strength => :does_not_exist) 
+    end.should raise_error(ArgumentError)
   end
 end
 
-# Requires @expect_relation, @invoke_relation and @target.
-describe 'composite set constraint', :shared => true do
-  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant target" do
-      @expect_relation.call(type, [1], false)
-      @invoke_relation.call(relation, [1], false)
-    end
-  end
-  
-  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable target" do
-      @expect_relation.call(type, @target, false)
-      @invoke_relation.call(relation, @target, false)
+describe 'constraint with kind option', :shared => true do
+  { :default  => Gecode::Raw::PK_DEF,
+    :speed    => Gecode::Raw::PK_SPEED,
+    :memory   => Gecode::Raw::PK_MEMORY
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation kind #{name}" do
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :pk => gecode_value)
+      invoke(operands, :kind => name)
     end
   end
   
-  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with constant target" do
-      @expect_relation.call(type, [1], true)
-      @invoke_relation.call(relation, [1], true)
-    end
+  it 'should default to using default as propagation kind' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
   end
   
-  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable target" do
-      @expect_relation.call(type, @target, true)
-      @invoke_relation.call(relation, @target, true)
-    end
-  end
-
-  it 'should raise error if the target is of the wrong type' do
+  it 'should raise errors for unrecognized propagation kinds' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_relation.call(:==, 'hello', false)
-    end.should raise_error(TypeError) 
+      invoke(operands, :kind => :does_not_exist)
+    end.should raise_error(ArgumentError)
   end
 end
 
 describe 'set constraint', :shared => true do
   it 'should not accept strength option' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:strength => :default)
+      invoke(operands, :strength => :default)
     end.should raise_error(ArgumentError)
   end
   
   it 'should not accept kind option' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:kind => :default)
+      invoke(operands, :kind => :default)
     end.should raise_error(ArgumentError)
   end
   
   it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:does_not_exist => :foo) 
+      invoke(operands, :does_not_exist => :foo) 
     end.should raise_error(ArgumentError)
   end
+
+  it_should_behave_like 'constraint'
 end
 
-# Requires @invoke_options and @model.
 describe 'non-reifiable set constraint', :shared => true do
   it 'should not accept reification option' do
     bool = @model.bool_var
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => bool)
+      invoke(operands, :reify => bool)
     end.should raise_error(ArgumentError)
   end
   
   it_should_behave_like 'set constraint'
 end
 
-# Requires @invoke_options, @expect_options and @model.
 describe 'reifiable set constraint', :shared => true do
   it_should_behave_like 'set constraint'
   it_should_behave_like 'constraint with reification option'
 end
-
-# Help methods for the GecodeR specs. 
-module GecodeR::Specs
-  module SetHelper
-    module_function
-  
-    # Returns the arguments that should be used in a partial mock to expect the
-    # specified constant set (possibly an array of arguments).
-    def expect_constant_set(constant_set)
-      if constant_set.kind_of? Range
-        return constant_set.first, constant_set.last
-      elsif constant_set.kind_of? Fixnum
-        constant_set
-      else
-        an_instance_of(Gecode::Raw::IntSet)
-      end
-    end
-  end
-end
-
-# Helper for creating @expect_option. Creates a method which takes a hash that
-# may have values for the keys :icl (ICL_*), :pk (PK_*), and :bool (reification 
-# variable). Expectations corresponding to the hash values are given to the 
-# specified block in the order of icl, pk and bool. Default values are provided 
-# if the hash doesn't specify anything else.
-def option_expectation(&block)
-  lambda do |hash|
-    bool = hash[:bool]
-    # We loosen the expectation some to avoid practical problems with expecting
-    # specific variables not under our control.
-    bool = an_instance_of(Gecode::Raw::BoolVar) unless bool.nil?
-    yield(hash[:icl] || Gecode::Raw::ICL_DEF,
-      hash[:pk]  || Gecode::Raw::PK_DEF,
-      bool)
-  end
-end

data/specs/constraints/constraint_receivers.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'constraint receiver', :shared => true do
+  it 'should raise error unless an operand of the correct type is given as lhs' do
+    lambda do
+      op = Object.new
+      class <<op
+        include Gecode::Operand
+      end
+      @receiver.new(@model, {:lhs => op, :negate => false})
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::ConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+  end
+
+  it 'should raise error if the negate params is not given' do
+    lambda do
+      Gecode::ConstraintReceiver.new(@model, {:lhs => nil})
+    end.should raise_error(ArgumentError)
+  end
+    
+  it 'should raise error if the lhs params is not given' do
+    lambda do
+      Gecode::ConstraintReceiver.new(@model, {:lhs => nil})
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe Gecode::Int::IntConstraintReceiver, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Int::IntConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::IntEnum::IntEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::IntEnum::IntEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::Bool::BoolConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Bool::BoolConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::BoolEnum::BoolEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::BoolEnum::BoolEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::Set::SetConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Set::SetConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SelectedSet::SelectedSetConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SelectedSet::SelectedSetConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SetElements::SetElementsConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SetElements::SetElementsConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SetEnum::SetEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SetEnum::SetEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end

data/specs/constraints/constraints.rb

@@ -1,83 +1,26 @@
 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 int 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::BoolEnum::Expression do
-  it 'should raise error unless lhs is a bool enum' do
-    lambda do
-      Gecode::Constraints::BoolEnum::Expression.new(Gecode::Model.new, 
-        :lhs => 'foo', :negate => false)
-    end.should raise_error(TypeError)
-  end
-end
-
-describe Gecode::Constraints::SetEnum::Expression do
-  it 'should raise error unless lhs is a set enum' do
-    lambda do
-      Gecode::Constraints::SetEnum::Expression.new(Gecode::Model.new, 
-        :lhs => 'foo', :negate => false)
-    end.should raise_error(TypeError)
-  end
-end
-
-describe Gecode::Constraints::Int::CompositeStub, ' (not subclassed)' do
-  before do
-    @con = Gecode::Constraints::Int::CompositeStub.new(Gecode::Model.new, {})
-  end
-
-  it 'should raise error when calling #constrain_equal' do
-    lambda do 
-      @con.instance_eval{ constrain_equal(nil, {}, false) }
-    end.should raise_error(NoMethodError)
-  end
-end
-
-describe Gecode::Constraints::Constraint, ' (not subclassed)' do
+describe Gecode::Constraint, ' (not subclassed)' do
   before do
-    @con = Gecode::Constraints::Constraint.new(Gecode::Model.new, {})
+    @con = Gecode::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)
+    lambda{ @con.post }.should raise_error(NotImplementedError)
   end
 end
 
-describe Gecode::Constraints::Util do
+describe Gecode::Util do
   it 'should raise error when giving incorrect set to #constant_set_to_params' do
     lambda do 
-      Gecode::Constraints::Util.constant_set_to_params('hello')
+      Gecode::Util.constant_set_to_params('hello')
     end.should raise_error(TypeError)
   end
   
   it 'should raise error when giving incorrect set to #constant_set_to_int_set' do
     lambda do 
-      Gecode::Constraints::Util.constant_set_to_int_set('hello')
+      Gecode::Util.constant_set_to_int_set('hello')
     end.should raise_error(TypeError)
   end
 end
 
-describe Gecode::Constraints::CompositeExpression do
-  it 'should raise error if a method doesn\'t exist' do
-    expression = Gecode::Constraints::CompositeExpression.new(
-      Gecode::Constraints::Int::Expression, Gecode::FreeIntVar, 
-      lambda{ }, Gecode::Model.new, {:lhs => nil, :negate => false}){}
-    lambda do
-      expression.this_method_does_not_exist
-    end.should raise_error(NoMethodError)
-  end
-end

data/specs/constraints/fixnum_enum/element.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class FixnumElementSampleProblem < Gecode::Model
+  attr :prices
+  attr :store
+  attr :price
+  
+  def initialize
+    prices = [17, 63, 45, 63]
+    @prices = wrap_enum(prices)
+    @store = int_var(0...prices.size)
+    @price = int_var(prices)
+    branch_on @store
+  end
+end
+
+describe Gecode::FixnumEnum::Element do
+  before do
+    @model = FixnumElementSampleProblem.new
+    @price = @model.price
+    @store = @model.store
+    @enum = @model.prices
+    
+    # For int operand producing property spec.
+    @property_types = [:fixnum_enum, :int]
+    @select_property = lambda do |fixnum_enum, int|
+      fixnum_enum[int]
+    end
+    @selected_property = @enum[@store]
+    @constraint_class = Gecode::BlockConstraint
+  end
+
+  it 'should not disturb normal array access' do
+    @enum[2].should_not be_nil
+  end
+
+  it 'should constrain the selected element' do
+    @enum[@store].must == @enum[2]
+    @model.solve!.should_not be_nil
+    @store.value.should equal(2)
+  end
+
+  it 'should be translated into an element constraint' do
+    @enum[@store].must == @price
+    @model.allow_space_access do
+      Gecode::Raw.should_receive(:element).once.with( 
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Array), 
+        @store.bind, @price.bind, 
+        Gecode::Raw::ICL_DEF,
+        Gecode::Raw::PK_DEF)
+    end
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end