gecoder 0.4.0 → 0.5.0

data/specs/constraints/constraint_helper.rb

@@ -45,4 +45,95 @@ describe 'constraint with options', :shared => true do
   end
   
   it_should_behave_like 'constraint with strength option'
+end
+
+# This requires that the constraint spec has the instance variable 
+# @expect_relation which takes a relation and right hand side as arguments and 
+# sets up the corresponding expectations. It also requires @invoke_relation and
+# @invoke_negated_relation with the same arguments. The spec is also required to 
+# provide an int var @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)
+    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
+  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
+    lambda do 
+      @invoke_relation.call(:==, 'hello', false)
+    end.should raise_error(TypeError) 
+  end
+end
+
+# Requires @invoke_options and @model.
+describe 'non-reifiable set constraint', :shared => true do
+  it 'should not accept strength option' do
+    lambda do 
+      @invoke_options.call(:strength => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not accept reification option' do
+    bool = @model.bool_var
+    lambda do 
+      @invoke_options.call(:reify => bool)
+    end.should raise_error(ArgumentError)
+  end
+end
+
+# Requires @invoke_options, @expect_options and @model.
+describe 'reifiable set constraint', :shared => true do
+  it 'should not accept strength option' do
+    lambda do 
+      @invoke_options.call(:strength => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should accept reification option' do
+    bool = @model.bool_var
+    @expect_options.call(nil, bool)
+    @invoke_options.call(:reify => bool)
+  end
+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

data/specs/constraints/constraints.rb

@@ -17,6 +17,18 @@ describe Gecode::Constraints::IntEnum::Expression do
   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, {}) }
+    end.should raise_error(NoMethodError)
+  end
+end
+
 describe Gecode::Constraints::Constraint, ' (not subclassed)' do
   before do
     @con = Gecode::Constraints::Constraint.new(Gecode::Model.new, {})
@@ -25,4 +37,23 @@ describe Gecode::Constraints::Constraint, ' (not subclassed)' do
   it 'should raise error when calling #post because it\'s not overridden' do
     lambda{ @con.post }.should raise_error(NoMethodError)
   end
+end
+
+describe Gecode::Constraints::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')
+    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, 
+      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/element.rb

@@ -21,92 +21,58 @@ describe Gecode::Constraints::IntEnum::Element do
   before do
     @model = ElementSampleProblem.new
     @prices = @model.prices
-    @price = @model.price
+    @target = @price = @model.price
     @store = @model.store
     @fixnum_prices = @model.fixnum_prices
     
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @prices[@store].must_be.greater_than(@price, hash) 
-      @model.solve!
-    end
-    @expect_options = lambda do |strength, reif_var|
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |element, relation, target, strength, reif_var, negated|
+      target = target.bind if target.respond_to? :bind
+      element = element.bind if element.respond_to? :bind
       if reif_var.nil?
-        Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar),
-          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), Gecode::Raw::IRT_GR,
-          an_instance_of(Gecode::Raw::IntVar), strength)
+        if !negated and relation == Gecode::Raw::IRT_EQ and 
+            target.kind_of? Gecode::Raw::IntVar 
+          Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, target, strength)
+        else
+          Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, 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, strength)
+        end
       else
         Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
           an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar),
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+          element, an_instance_of(Gecode::Raw::IntVar), strength)
         Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR,
-          an_instance_of(Gecode::Raw::IntVar), 
+          an_instance_of(Gecode::Raw::IntVar), relation, target, 
           an_instance_of(Gecode::Raw::BoolVar), strength)
       end
     end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable right hand side" do
-      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVar),
-        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
-      unless type == Gecode::Raw::IRT_EQ
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
-          an_instance_of(Gecode::Raw::IntVar), type,
-          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
-      end
-      @prices[@store].must.send(relation, @price)
-      @model.solve!
-    end
-  end
 
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable right hand side" do
-      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVar),
-        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::IntVar), type,
-        an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
-      @prices[@store].must_not.send(relation, @price)
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @prices[@store].must_be.greater_than(@price, hash) 
       @model.solve!
     end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant right hand side" do
-      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVar),
-        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
-      unless type == Gecode::Raw::IRT_EQ
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
-          an_instance_of(Gecode::Raw::IntVar), type, 5, an_instance_of(Fixnum))
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@store, Gecode::Raw::IRT_GR, @price, strength, reif_var, 
+        false)
+    end
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @prices[@store].must_not.send(relation, target)
+      else
+        @prices[@store].must.send(relation, target)
       end
-      @prices[@store].must.send(relation, 5)
       @model.solve!
     end
-  end
-
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with constant right hand side" do
-      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVar),
-        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
-        an_instance_of(Gecode::Raw::IntVar), type, 5, an_instance_of(Fixnum))
-      @prices[@store].must_not.send(relation, 5)
-      @model.solve!
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(@store, relation, target, Gecode::Raw::ICL_DEF, nil, negated)
     end
   end
 
@@ -119,10 +85,15 @@ describe Gecode::Constraints::IntEnum::Element do
     @fixnum_prices[@store].must == @fixnum_prices[2]
     @model.solve!.store.val.should equal(2)
   end
-
-  it 'should raise error on right hand sides of the wrong type' do
-    lambda{ @prices[@store].must == 'hello' }.should raise_error(TypeError) 
+  
+  it 'should translate reification when using equality' do
+    bool_var = @model.bool_var
+    @expect.call(@store, Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, 
+      bool_var, false)
+    @prices[@store].must_be.equal_to(@target, :reify => bool_var)
+    @model.solve!
   end
   
+  it_should_behave_like 'composite constraint'
   it_should_behave_like 'constraint with options'
 end

data/specs/constraints/{domain.rb → int_domain.rb}

@@ -52,5 +52,9 @@ describe Gecode::Constraints::Int::Domain do
     @x.should have_domain(@domain.to_a - @range_domain.to_a)
   end
   
+  it 'should raise error if the right hand side is not an enumeration' do
+    lambda{ @x.must_be.in 'hello' }.should raise_error(TypeError)
+  end
+  
   it_should_behave_like 'constraint with options'
 end

data/specs/constraints/set_domain.rb

@@ -0,0 +1,165 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Set::Domain do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @glb = [0]
+    @lub = 0..3
+    @set = @model.set_var(@glb, @lub)
+    @range = 0..1
+    @non_range = [0, 2]
+    @singleton = 0
+    
+    @expect = lambda do |relation_type, rhs, reif_var, negated|
+      if reif_var.nil? and !negated
+        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+          @set.bind, relation_type, *expect_constant_set(rhs))
+      else
+        params = [@model.active_space, @set.bind, relation_type]
+        params << expect_constant_set(rhs)
+        params << an_instance_of(Gecode::Raw::BoolVar)
+        Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.superset_of(@non_range, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_SUP, @non_range, reif_var, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    next if relation == :==
+  
+    it "should translate #{relation} with constant range to domain constraint" do
+      @expect.call(type, @range, nil, false)
+      @set.must.send(relation, @range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant non-range to domain constraint" do
+      @expect.call(type, @non_range, nil, false)
+      @set.must.send(relation, @non_range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant singleton to domain constraint" do
+      @expect.call(type, @singleton, nil, false)
+      @set.must.send(relation, @singleton)
+      @model.solve!
+    end
+  
+    it "should translate negated #{relation} with constant range to domain constraint" do
+      @expect.call(type, @range, nil, true)
+      @set.must_not.send(relation, @range)
+      @model.solve!
+    end
+    
+    it "should translate negated #{relation} with constant non-range to domain constraint" do
+      @expect.call(type, @non_range, nil, true)
+      @set.must_not.send(relation, @non_range)
+      @model.solve!
+    end
+    
+    it "should translate negated #{relation} with constant singleton to domain constraint" do
+      @expect.call(type, @singleton, nil, true)
+      @set.must_not.send(relation, @singleton)
+      @model.solve!
+    end
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Domain, ' (equality)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @glb = [0]
+    @lub = 0..3
+    @set = @model.set_var(@glb, @lub)
+    @range = 0..1
+    @non_range = [0, 2]
+    @singleton = 0
+    
+    @expect = lambda do |relation_type, rhs, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+          @set.bind, relation_type, *expect_constant_set(rhs))
+      else
+        params = [@model.active_space, @set.bind, relation_type]
+        params << expect_constant_set(rhs)
+        params << an_instance_of(Gecode::Raw::BoolVar)
+        Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.equal_to(@non_range, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_EQ, @non_range, reif_var)
+    end
+  end
+  
+  it 'should translate equality with constant range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @range, nil)
+    @set.must == @range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant non-range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @non_range, nil)
+    @set.must == @non_range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant singleton to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @singleton, nil)
+    @set.must == @singleton
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @range, nil)
+    @set.must_not == @range
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant non-range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @non_range, nil)
+    @set.must_not == @non_range
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant singleton to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @singleton, nil)
+    @set.must_not == @singleton
+    @model.solve!
+  end
+  
+  it 'should constrain the domain with equality' do
+    @set.must == @singleton
+    @model.solve!
+    @set.should be_assigned
+    @set.should include(@singleton)
+    @set.val_size.should == 1
+  end
+  
+  it 'should constrain the domain with inequality' do
+    @set.must_not == @singleton
+    @model.solve!.should be_nil
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end

data/specs/constraints/set_relation.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Set::Relation do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([0], 0..3)
+    @set2 = @model.set_var([1], 0..3)
+    
+    @expect = lambda do |relation_type, rhs, reif_var, negated|
+      if reif_var.nil? and !negated
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          @set.bind, relation_type, @set2.bind)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          @set.bind, relation_type, @set2.bind, 
+          an_instance_of(Gecode::Raw::BoolVar))
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.superset_of(@set2, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_SUP, @set2, reif_var, false)
+    end
+  end
+
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    next if relation == :==
+  
+    it "should translate #{relation} with set to relation constraint" do
+      @expect.call(type, @set2, nil, false)
+      @set.must.send(relation, @set2)
+      @model.solve!
+    end
+  
+    it "should translate negated #{relation} with set to relation constraint" do
+      @expect.call(type, @set2, nil, true)
+      @set.must_not.send(relation, @set2)
+      @model.solve!
+    end
+  end
+  it_should_behave_like 'reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Relation, ' (equality)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([0], 0..1)
+    @set2 = @model.set_var([1], 0..1)
+    
+    @expect = lambda do |relation_type, rhs, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          @set.bind, relation_type, @set2.bind)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          @set.bind, relation_type, @set2.bind, 
+          an_instance_of(Gecode::Raw::BoolVar))
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.equal_to(@set2, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_EQ, @set2, reif_var)
+    end
+  end
+  
+  it 'should translate equality with set to relation constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @set2, nil)
+    @set.must == @set2
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with set to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @set2, nil)
+    @set.must_not == @set2
+    @model.solve!
+  end
+  
+  it 'should constrain sets to be equality when not negated' do
+    @set.must == @set2
+    @model.solve!
+    @set.should have_bounds(0..1, 0..1)
+    @set2.should have_bounds(0..1, 0..1)
+  end
+  
+  it 'should constrain sets to not be equal when negated' do
+    @set.must_not == @set2
+    union = @model.set_var([0, 1], [0, 1])
+    @set.must_not == union
+    @set2.must_not == union
+    @model.solve!
+    @set.should have_bounds([0], [0])
+    @set2.should have_bounds([1], [1])
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Relation, ' (elements)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([0], 0..2)
+    @int_var = @model.int_var(0..2)
+    @int_constant = 2
+    @model.branch_on @model.wrap_enum([@set])
+    @expect = lambda do |relation_type, rhs|
+      if rhs.kind_of? Fixnum
+        rhs = an_instance_of(Gecode::Raw::IntVar)
+      end
+      rhs = rhs.bind if rhs.respond_to? :bind
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        @set.bind, relation_type, rhs)
+    end
+    
+    @invoke_options = lambda do |hash|
+      @set.elements.must_be.equal_to(@int_var, hash)
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable to relation constraint" do
+      @expect.call(type, @int_var)
+      @set.elements.must.send(relation, @int_var)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant to relation constraint" do
+      @expect.call(type, @int_constant)
+      @set.elements.must.send(relation, @int_constant)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable to relation constraint" do
+      @expect.call(type, @int_var)
+      @set.elements.must_not.send(relation, @int_var)
+      @model.solve!
+    end
+    
+    it "should translate negated #{relation} with constant to relation constraint" do
+      @expect.call(type, @int_constant)
+      @set.elements.must_not.send(relation, @int_constant)
+      @model.solve!
+    end
+  end
+  
+  it 'should constrain the elements of the set' do
+    @set.elements.must <= @int_var
+    @int_var.must == 0
+    @model.solve!
+    @set.should be_assigned
+    @set.should include(0)
+    @set.should_not include(1,2)
+  end
+  
+  it 'should constrain the elements of the set (constant parameter)' do
+    @set.elements.must <= 0
+    @model.solve!
+    @set.should be_assigned
+    @set.should include(0)
+    @set.should_not include(1,2)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end

data/specs/enum_wrapper.rb

@@ -80,11 +80,22 @@ end
 describe Gecode::BoolEnumMethods do
   before do
     @model = Gecode::Model.new
-    @int_enum = @model.bool_var_array(3)
+    @bool_enum = @model.bool_var_array(3)
   end
   
   it 'should convert to a bool var array' do
-    @int_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+    @bool_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+  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
+    @set_enum.to_set_var_array.should be_kind_of(Gecode::Raw::SetVarArray)
   end
 end