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

data/specs/constraints/set_enum/select.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class SelectionSampleProblem < Gecode::Model
+  attr :sets
+  attr :set
+  attr :target
+  attr :index
+  
+  def initialize
+    @sets = set_var_array(3, [], 0..20)
+    @set = set_var([], 0...3)
+    @target = set_var([], 0..20)
+    @index = int_var(0...3)
+    branch_on wrap_enum([@index])
+    branch_on @sets
+  end
+end
+
+# Requires everything that composite behaviour spec requires in addition to
+# @stub and @expect_constrain_equal .
+describe 'selection constraint', :shared => true do
+  it 'should not disturb normal array access' do
+    @sets[0].should be_kind_of(Gecode::SetVar)
+  end
+end
+
+describe Gecode::SetEnum::Select, ' (int operand)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @target = @set = @model.target
+    @index = @model.index
+    @model.branch_on @model.wrap_enum([@set])
+    @stub = @sets[@index]
+    
+    @property_types = [:set_enum, :int]
+    @select_property = lambda do |set_enum, int|
+      set_enum[int]
+    end
+    @selected_property = @sets[@index]
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the specified element of an enum of sets' do
+    @sets[@index].must_be.superset_of([5,7,9])
+    @model.solve!
+    @sets[@index.value].value.should include(5,7,9)
+  end
+
+  it 'should translate into a select constraint' do
+    Gecode::Raw.should_receive(:selectSet)
+    @sets[@index].must_be.superset_of([5,7,9])
+    @model.solve!
+  end
+  
+  it_should_behave_like 'selection constraint'
+  it_should_behave_like(
+    'property that produces set operand by short circuiting equality')
+end
+
+describe Gecode::SetEnum::Select, ' (set operand)' do
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+  end
+  
+  it 'should produce a selected set operand' do
+    @sets[@set].should be_respond_to(:to_selected_set)
+  end
+end

data/specs/distribution.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Interface installed on win32 systems' do
+  it 'should be able to load the libraries' do
+    # Admittably this is not an especially good test for the library loading 
+    # under Windows. It only makes sure that there are no execution errors. This
+    # has to be tested in a proper Windows environment to tell whether library
+    # loading actually works.
+    RUBY_PLATFORM = 'i386-mswin32'
+    lambda do
+      Gecode.load_bindings_lib
+    end.should_not raise_error
+  end
+end

data/specs/enum_matrix.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::Util::EnumMatrix do
+  before do
+    @matrix = Gecode::Util::EnumMatrix[[0, 1], [1, 0]]
+  end
+  
+  it 'should be enumerable' do
+    @matrix.should be_kind_of(Enumerable)
+  end
+  
+  it 'should produce rows that are enumerable' do
+    @matrix.row(0).should be_kind_of(Enumerable)
+    @matrix.row(0).inject([]){ |arr, e| arr << e }.should == [0, 1]
+  end
+  
+  it 'should produce columns that are enumerable' do
+    @matrix.column(0).should be_kind_of(Enumerable)
+  end
+  
+  it 'should produce submatrices that are enumerable' do
+    @matrix.minor(0,1,0,1).should be_kind_of(Enumerable)
+  end
+end
+
+describe Gecode::Util::EnumMatrix, ' (when wrapped)' do
+  before do
+    @model = Gecode::Model.new
+    @matrix = @model.wrap_enum(Gecode::Util::EnumMatrix[[0, 1], [1, 0]])
+  end
+  
+  it 'should produce rows that are wrapped' do
+    @matrix.row(0).should respond_to(:model)
+  end
+  
+  it 'should produce columns that are enumerable' do
+    @matrix.column(0).should respond_to(:model)
+  end
+  
+  it 'should produce submatrices that are enumerable' do
+    @matrix.minor(0,1,0,1).should respond_to(:model)
+  end
+end

data/specs/enum_wrapper.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::Model, ' (enum wrapping)' do
+  before do
+    @model = Gecode::Model.new
+    @bool = @model.bool_var
+    @int = @model.int_var(1..2)
+    @set = @model.set_var([], 1..2)
+  end
+
+  it 'should only allow enumerables to be wrapped' do
+    lambda do
+      @model.wrap_enum(17) 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should allow enumerables of bool variables to be wrapped' do
+    lambda do
+      enum = [@bool]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+
+  it 'should allow enumerables of bool operands to be wrapped' do
+    lambda do
+      enum = [@bool & @bool]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  it 'should allow enumerables of int variables to be wrapped' do
+    lambda do
+      enum = [@int]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+
+  it 'should allow enumerables of int operands to be wrapped' do
+    lambda do
+      enum = [@int + @int]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+
+  it 'should allow enumerables of set variables to be wrapped' do
+    lambda do
+      enum = [@set]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+
+  it 'should allow enumerables of set operands to be wrapped' do
+    lambda do
+      enum = [@set.union(@set)]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  
+  it 'should allow enumerables of fixnums to be wrapped' do
+    lambda do
+      enum = [17]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  it 'should not allow empty enumerables to be wrapped' do
+    lambda do 
+      @model.wrap_enum([]) 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not allow wrapping a wrapped enumerable' do
+    lambda do 
+      enum = [@bool]
+      @model.wrap_enum(@model.wrap_enum(enum)) 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not allow enumerables without variables or fixnums to be wrapped' do
+    lambda do 
+      @model.wrap_enum(['foo']) 
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should not allow enumerables with only some variables to be wrapped' do
+    lambda do 
+      enum = [@bool, 'foo']
+      @model.wrap_enum(enum) 
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should not allow enumerables with mixed types of variables to be wrapped' do
+    lambda do 
+      enum = [@bool, @int]
+      @model.wrap_enum(enum) 
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::IntEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @int_enum = @model.int_var_array(3, 0..1)
+  end
+  
+  it 'should convert to an int var array' do
+    @model.allow_space_access do
+      @int_enum.bind_array.should be_kind_of(Gecode::Raw::IntVarArray)
+    end
+  end
+  
+  it 'should compute the smallest domain range' do
+    @int_enum.domain_range.should == (0..1)
+    (@int_enum << @model.int_var(-4..4)).domain_range.should == (-4..4)
+  end
+
+  it 'should define #to_int_enum' do
+    @int_enum.to_int_enum.should be_kind_of(
+      Gecode::IntEnum::IntEnumOperand)
+  end
+end
+
+describe Gecode::BoolEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @bool_enum = @model.bool_var_array(3)
+  end
+  
+  it 'should convert to a bool var array' do
+    @model.allow_space_access do
+      @bool_enum.bind_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+    end
+  end
+  
+  it 'should define #to_bool_enum' do
+    @bool_enum.to_bool_enum.should be_kind_of(
+      Gecode::BoolEnum::BoolEnumOperand)
+  end
+end
+
+describe Gecode::SetEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @set_enum = @model.set_var_array(3, [0], 0..1)
+  end
+  
+  it 'should convert to a set var array' do
+    @model.allow_space_access do
+      @set_enum.bind_array.should be_kind_of(Gecode::Raw::SetVarArray)
+    end
+  end
+  
+  it 'should compute the smallest upper bound union range' do
+    @set_enum.upper_bound_range.should == (0..1)
+    (@set_enum << @model.set_var([], -4..4)).upper_bound_range.should == (-4..4)
+  end
+  
+  it 'should define #to_set_enum' do
+    @set_enum.to_set_enum.should be_kind_of(
+      Gecode::SetEnum::SetEnumOperand)
+  end
+end
+
+describe Gecode::FixnumEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @enum = @model.instance_eval{ wrap_enum([7, 14, 17, 4711]) }
+  end
+  
+  it 'should compute the smallest domain range' do
+    @enum.domain_range.should == (7..4711)
+  end
+  
+  it 'should define #to_fixnum_enum' do
+    @enum.to_fixnum_enum.should be_kind_of(
+      Gecode::FixnumEnum::FixnumEnumOperand)
+  end
+end

data/specs/examples.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'open3'
+
+# This spec checks that the examples are still working.
+files = Dir["#{File.dirname(__FILE__)}/../example/*.rb"]
+files.delete_if do |file|
+  file =~ /example_helper.rb/
+end
+
+files.each do |example|
+  describe "Example (#{File.basename(example)})" do
+    it 'should not output errors' do
+      _, _, stderr = Open3.popen3("ruby #{example} 1> /dev/null")
+      stderr.gets.should be_nil
+    end
+  end
+end

data/specs/int_var.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/constraints/property_helper'
+
+describe 'non-empty int variable', :shared => true do
+  it 'should have min equal to the lower domain bound' do
+    @var.min.should equal(@domain.min)
+  end
+  
+  it 'should have max equal to the upper domain bound' do
+    @var.max.should equal(@domain.max)
+  end
+  
+  it 'should have size equal to the domain size' do
+    @var.size.should equal(@domain.size)
+  end
+  
+  it 'should contain every element in its domain' do 
+    @domain.each do |i|
+      @var.should include(i)
+    end
+  end
+  
+  it 'should not contain elements outside its domain' do
+    @var.should_not include(@domain.min - 1)
+    @var.should_not include(@domain.max + 1)
+  end
+  
+  it 'should have a width equal to the domain width' do
+    @var.width.should equal(@domain.max - @domain.min + 1)
+  end
+  
+  it 'should give a NoMethodError when calling a method that doesn\'t exist' do
+    lambda{ @var.this_method_does_not_exists }.should raise_error(NoMethodError)
+  end
+  
+  it 'should have a zero degree' do
+    @var.degree.should be_zero
+  end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == @domain.to_a
+  end
+
+  it_should_behave_like 'int var operand'
+end
+
+describe Gecode::IntVar, ' (with range domain of size > 1)' do
+  before do
+    @range = -4..3
+    @domain = @range.to_a
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@range)
+  end
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should have a range domain' do
+    @var.should be_range
+  end
+  
+  it 'should raise error when trying to access assigned value' do
+    lambda{ @var.value }.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like 'non-empty int variable'
+end
+
+describe Gecode::IntVar, ' (defined with three-dot range)' do
+  before do
+    @range = -4...3
+    @domain = @range.to_a
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@range)
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+end
+
+describe Gecode::IntVar, ' (with non-range domain of size > 1)' do
+  before do
+    @domain = [-3, -2, -1, 1]
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@domain)
+  end
+
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should not be a range domain' do
+    @var.should_not be_range
+  end
+  
+  it 'should not contain the domain\'s holes' do
+    @var.should_not include(0)
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+end
+
+describe Gecode::IntVar, ' (with a domain of size 1)' do
+  before do
+    @domain = [1]
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(*@domain)
+  end
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should be a range domain' do
+    @var.should be_range
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+end
+
+describe Gecode::IntVar, ' (assigned)' do
+  before do
+    @domain = 1
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(*@domain)
+  end
+
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should give the assigned number when inspecting' do
+    @var.inspect.should include(" #{@domain[0]}>")
+  end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == [@domain]
+  end
+
+  it_should_behave_like 'int var operand'
+end
+
+describe Gecode::IntVar, ' (not assigned)' do
+  before do
+    @domain = 1..2
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@domain)
+  end
+
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should give the domain range when inspecting' do
+    @var.inspect.should include(" #{@domain.first}..#{@domain.last}>")
+  end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == @domain.to_a
+  end
+
+  it_should_behave_like 'int var operand'
+end