RSpec Results

 

 

Gecode::BoolVar (not assigned)
should give a NoMethodError when calling a method that doesn't exist
should not be assigned
should say that it's not assigned when inspecting
should raise error when trying to access assigned value
should implement #model
should implement #to_bool_var
should implement #must
Gecode::BoolVar (assigned true)
should give a NoMethodError when calling a method that doesn't exist
should be assigned
should have valye true
should say that it's true when inspecting
should implement #model
should implement #to_bool_var
should implement #must
Gecode::BoolVar (assigned false)
should give a NoMethodError when calling a method that doesn't exist
should be assigned
should have value false
should say that it's false when inspecting
should implement #model
should implement #to_bool_var
should implement #must
Gecode::Mixin (integer branch)
should default to :none and :min
should ensure that branched int variables are assigned in a solution
should ensure that branched bool variables are assigned in a solution
should allow branching on a single integer variable
should allow branching on a single boolean variable
should support largest_min as variable selection strategy
should support largest_degree as variable selection strategy
should support smallest_max as variable selection strategy
should support smallest_min_regret as variable selection strategy
should support largest_max as variable selection strategy
should support largest_min_regret as variable selection strategy
should support smallest_size as variable selection strategy
should support smallest_max_regret as variable selection strategy
should support none as variable selection strategy
should support largest_size as variable selection strategy
should support largest_max_regret as variable selection strategy
should support smallest_min as variable selection strategy
should support smallest_degree as variable selection strategy
should support min as value selection strategy
should support med as value selection strategy
should support max as value selection strategy
should support split_min as value selection strategy
should support split_max as value selection strategy
should raise errors for unrecognized var selection strategies
should raise errors for unrecognized val selection strategies
should raise errors for unrecognized options
should raise errors for unrecognized enumerations
Gecode::Mixin (set branch)
should default to :none and :min
should ensure that branched set variables are assigned in a solution
should allow branching on a single set variable
should support smallest_cardinality as variable selection strategy
should support largest_cardinality as variable selection strategy
should support smallest_unknown as variable selection strategy
should support largest_unknown as variable selection strategy
should support none as variable selection strategy
should support min as value selection strategy
should support max as value selection strategy
should raise errors for unrecognized var selection strategies
should raise errors for unrecognized val selection strategies
should raise errors for unrecognized options
Gecode::Bool (must be true)
should constrain variables to be true
should make negation constrain variables to not be true
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Bool (must be false)
should constrain variables to be false
should make negation constrain variables to not be false
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Bool (implies)
should constrain variables to imply each other
should, when negated, constrain variables to not imply each other
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Bool (equality)
should constrain variables to equal each other
should, when negated, constrain variables to not equal each other
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Bool
should handle single variables constrainted to be true
should handle single variables constrainted to be false
should handle single variables constrainted not to be false
should handle single variables constrainted not to be true
should handle disjunction
should handle negated disjunction
should handle conjunction
should handle negated conjunction
should handle exclusive or
should handle negated exclusive or
should handle implication
should handle negated implication
should handle imply after must
should handle imply after must_not
should handle single variables as right hand side
should handle single variables with negation as right hand side
should handle expressions as right hand side
should handle nested expressions as left hand side
should handle nested expressions on both side
should handle nested expressions with implication
should handle nested expressions containing exclusive or
should handle nested expressions on both sides with negation
should translate reification with a variable right hand side
should translate reification with a variable right hand side and negation
Gecode::Bool (& property)
should constrain the conjunction/disjunction/exclusive disjunction
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::Bool (| property)
should constrain the conjunction/disjunction/exclusive disjunction
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::Bool (^ property)
should constrain the conjunction/disjunction/exclusive disjunction
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::Bool (#implies property)
should constrain the implication
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Linear (with booleans)
should handle addition with a variable
should handle reification (1)
should handle reification (2)
should handle addition with multiple variables
should handle subtraction with a variable
should handle non-zero constants as right hand side
should handle single booleans as left hand side
should handle single booleans as left hand side (2)
should handle single booleans as left hand side (3)
should handle variables as right hand side
should handle linear expressions as right hand side
should raise error on invalid right hand sides
should raise error if a fixnum is not used in multiplication
should raise error if bools are combined with integer variables
should handle coefficients other than 1
should handle addition with constants
should handle subtraction with a constant
should handle parenthesis
should handle multiplication of parenthesis
should handle > with constant integers
should handle >= with constant integers
should handle < with constant integers
should handle <= with constant integers
should handle == with constant integers
should handle negated > with constant integers
should handle negated >= with constant integers
should handle negated < with constant integers
should handle negated <= with constant integers
should handle negated == with constant integers
Gecode::BoolEnum::Relation (conjunction)
should handle being constrained to be true
should handle being constrained to be negated true
should handle being constrained to be false
should handle being constrained to be negated false
should handle being constrained to be equal to a variable
should handle being constrained to not be equal to a variable
should handle being constrained to be equal to be a nested expression
should handle being constrained to not be equal to be a nested expression
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::BoolEnum::Relation (disjunction)
should handle being constrained to be true
should handle being constrained to be negated true
should handle being constrained to be false
should handle being constrained to be negated false
should handle being constrained to be equal to a variable
should handle being constrained to not be equal to a variable
should handle being constrained to be equal to be a nested expression
should handle being constrained to not be equal to be a nested expression
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce bool operand
should raise errors if parameters of the incorrect type are given
Gecode::BoolEnum::Channel (bool enum as lhs with int variable)
should channel the bool enum with the integer variable
should take the offset into account when channeling
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::BoolEnum::Channel (int variable as lhs with bool enum)
should channel the bool enum with the integer variable
should take the offset into account when channeling
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::BoolEnum::Extensional (tuple constraint)
should constrain the domain of all variables
should raise error if the right hand side is not an enumeration
should raise error if the right hand side does not contain tuples
should not allow negation
should not allow empty tuples
should not allow tuples of sizes other than the number of variables
should raise error if the right hand side does not contain tuples of correct type
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
Gecode::BoolEnum::Extensional (regexp constraint)
should handle the any operation
should handle the any operator with nested expressions
should handle values grouped in a single array
should allow nested groups of values
should handle the repeat operation
should handle repeat operations that do not encase constant values in arrays
should handle nested repeat operations
should handle nested repeat operations (2)
should interpret the repeat operation with the last argument omitted as only giving a lower bound
should interpret the repeat operation with all but the first argument omitted as not giving any bound
should interpret the repeat operation with all but the first argument omitted as not giving any bound (2)
should translate at_most_once(reg) to repeat(reg, 0, 1)
should translate at_least_once(reg) to repeat(reg, 1)
should raise error if the right hand side is not an enumeration
should raise error if the right hand side does not a regexp of the right type
should raise error if the right hand side contains a nested element of an incorrect type
should raise error if the repeat operation is given arguments of incorrect type (2)
should raise error if the repeat operation is given arguments of incorrect type (3)
should raise error if the repeat operation is given arguments of incorrect type
should not allow negation
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
Gecode::ConstraintReceiver
should raise error if the negate params is not given
should raise error if the lhs params is not given
Gecode::Int::IntConstraintReceiver (not subclassed)
should raise error unless an operand of the correct type is given as lhs
Gecode::IntEnum::IntEnumConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::Bool::BoolConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::BoolEnum::BoolEnumConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::Set::SetConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::SelectedSet::SelectedSetConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::SetElements::SetElementsConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::SetEnum::SetEnumConstraintReceiver
should raise error unless an operand of the correct type is given as lhs
Gecode::Constraint (not subclassed)
should raise error when calling #post because it's not overridden
Gecode::Util
should raise error when giving incorrect set to #constant_set_to_params
should raise error when giving incorrect set to #constant_set_to_int_set
Gecode::FixnumEnum::Element
should not disturb normal array access
should constrain the selected element
should be translated into an element constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (disjoint_union with set variable)
should translate disjoint_union into an operation constraint
should constrain the disjoint_union of the sets with variable rhs
should not allow constant sets to be given as argument
should not allow all three parameters to be constant sets
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (minus with set variable)
should translate minus into an operation constraint
should constrain the minus of the sets with variable rhs
should not allow constant sets to be given as argument
should not allow all three parameters to be constant sets
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (intersection with set variable)
should translate intersection into an operation constraint
should constrain the intersection of the sets with variable rhs
should not allow constant sets to be given as argument
should not allow all three parameters to be constant sets
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (union with set variable)
should translate union into an operation constraint
should constrain the union of the sets with variable rhs
should not allow constant sets to be given as argument
should not allow all three parameters to be constant sets
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Arithmetic (abs)
should constrain the absolute value
should translate into an abs constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Arithmetic (multiplication)
should constrain the value of the multiplication
should translate into a mult constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Arithmetic (squared)
should constrain the value of the variable squared
should translate into a squared constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Arithmetic (square root)
should constrain the square root of the variable
should constrain the square root of the variable (2)
should constrain the square root of the variable (3)
should round down the square root
should translate into a square root constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Channel (one int and one bool variable)
should not shadow linear boolean constraints
should constrain the int variable to be 1 when the boolean variable is true
should constrain the int variable to be 0 when the boolean variable is false
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Int::Channel (one bool and one int variable)
should not shadow linear boolean constraints
should constrain the int variable to be 1 when the boolean variable is true
should constrain the int variable to be 0 when the boolean variable is false
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Int::Domain (non-range)
should constrain the domain of the variable
should handle negation
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Domain (range)
should constrain the domain of the variable
should handle negation
should treat three dot ranges correctly
should handle three dot range with negation
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Linear
should handle addition with a variable
should handle reification (1)
should handle reification (2)
should handle addition with multiple variables
should handle subtraction with a variable
should handle non-zero constants as right hand side
should handle variables as right hand side
should handle linear expressions as right hand side
should handle linear expressions as right hand side with variable as left hand side
should raise error on invalid right hand sides
should handle coefficients other than 1
should handle addition with constants
should handle subtraction with a constant
should a single variable as left hande side
should handle parenthesis
should handle multiplication of parenthesis
should handle > with constant integers
should handle >= with constant integers
should handle < with constant integers
should handle <= with constant integers
should handle == with constant integers
should handle negated > with constant integers
should handle negated >= with constant integers
should handle negated < with constant integers
should handle negated <= with constant integers
should handle negated == with constant integers
Gecode::Int::Linear (+ property)
should constrain the sum
should produce reifiable constraints when short circuited
should give the same solution regardless of whether short circuit > was used
should short circuit >
should short circuit negated >
should short circuit > when reification is used
should short circuit > even when the right hand side is a fixnum
should raise error when the > right hand side is of illegal type
should give the same solution regardless of whether short circuit >= was used
should short circuit >=
should short circuit negated >=
should short circuit >= when reification is used
should short circuit >= even when the right hand side is a fixnum
should raise error when the >= right hand side is of illegal type
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should short circuit negated ==
should short circuit == when reification is used
should short circuit == even when the right hand side is a fixnum
should raise error when the == right hand side is of illegal type
should give the same solution regardless of whether short circuit < was used
should short circuit <
should short circuit negated <
should short circuit < when reification is used
should short circuit < even when the right hand side is a fixnum
should raise error when the < right hand side is of illegal type
should give the same solution regardless of whether short circuit <= was used
should short circuit <=
should short circuit negated <=
should short circuit <= when reification is used
should short circuit <= even when the right hand side is a fixnum
should raise error when the <= right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Linear (- property)
should constrain the difference
should produce reifiable constraints when short circuited
should give the same solution regardless of whether short circuit > was used
should short circuit >
should short circuit negated >
should short circuit > when reification is used
should short circuit > even when the right hand side is a fixnum
should raise error when the > right hand side is of illegal type
should give the same solution regardless of whether short circuit >= was used
should short circuit >=
should short circuit negated >=
should short circuit >= when reification is used
should short circuit >= even when the right hand side is a fixnum
should raise error when the >= right hand side is of illegal type
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should short circuit negated ==
should short circuit == when reification is used
should short circuit == even when the right hand side is a fixnum
should raise error when the == right hand side is of illegal type
should give the same solution regardless of whether short circuit < was used
should short circuit <
should short circuit negated <
should short circuit < when reification is used
should short circuit < even when the right hand side is a fixnum
should raise error when the < right hand side is of illegal type
should give the same solution regardless of whether short circuit <= was used
should short circuit <=
should short circuit negated <=
should short circuit <= when reification is used
should short circuit <= even when the right hand side is a fixnum
should raise error when the <= right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Linear (* property)
should constrain the value times a constant
should produce reifiable constraints when short circuited
should give the same solution regardless of whether short circuit > was used
should short circuit >
should short circuit negated >
should short circuit > when reification is used
should short circuit > even when the right hand side is a fixnum
should raise error when the > right hand side is of illegal type
should give the same solution regardless of whether short circuit >= was used
should short circuit >=
should short circuit negated >=
should short circuit >= when reification is used
should short circuit >= even when the right hand side is a fixnum
should raise error when the >= right hand side is of illegal type
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should short circuit negated ==
should short circuit == when reification is used
should short circuit == even when the right hand side is a fixnum
should raise error when the == right hand side is of illegal type
should give the same solution regardless of whether short circuit < was used
should short circuit <
should short circuit negated <
should short circuit < when reification is used
should short circuit < even when the right hand side is a fixnum
should raise error when the < right hand side is of illegal type
should give the same solution regardless of whether short circuit <= was used
should short circuit <=
should short circuit negated <=
should short circuit <= when reification is used
should short circuit <= even when the right hand side is a fixnum
should raise error when the <= right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (> with int op)
should constrain the > with an int operand
should constrain the negated > with an int operand
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (>= with int op)
should constrain the >= with an int operand
should constrain the negated >= with an int operand
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (== with int op)
should constrain the == with an int operand
should constrain the negated == with an int operand
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (< with int op)
should constrain the < with an int operand
should constrain the negated < with an int operand
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (<= with int op)
should constrain the <= with an int operand
should constrain the negated <= with an int operand
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (> with fixnum)
should constrain the > with a fixnum
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (>= with fixnum)
should constrain the >= with a fixnum
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (== with fixnum)
should constrain the == with a fixnum
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (< with fixnum)
should constrain the < with a fixnum
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::Int::Relation (<= with fixnum)
should constrain the <= with a fixnum
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Arithmetic (max)
should constrain the maximum value
should translate into a max constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Arithmetic (min)
should constrain the minimum value
should translate into a min constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Channel (two int enums)
should translate into a channel constraint
should constrain variables to be channelled
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Count (with int var)
should constrain the count
should produce reifiable constraints when short circuited
should give the same solution regardless of whether short circuit > was used
should short circuit >
should short circuit negated >
should short circuit > when reification is used
should short circuit > even when the right hand side is a fixnum
should raise error when the > right hand side is of illegal type
should give the same solution regardless of whether short circuit >= was used
should short circuit >=
should short circuit negated >=
should short circuit >= when reification is used
should short circuit >= even when the right hand side is a fixnum
should raise error when the >= right hand side is of illegal type
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should short circuit negated ==
should short circuit == when reification is used
should short circuit == even when the right hand side is a fixnum
should raise error when the == right hand side is of illegal type
should give the same solution regardless of whether short circuit < was used
should short circuit <
should short circuit negated <
should short circuit < when reification is used
should short circuit < even when the right hand side is a fixnum
should raise error when the < right hand side is of illegal type
should give the same solution regardless of whether short circuit <= was used
should short circuit <=
should short circuit negated <=
should short circuit <= when reification is used
should short circuit <= even when the right hand side is a fixnum
should raise error when the <= right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Count (with fixnum)
should constrain the count
should produce reifiable constraints when short circuited
should give the same solution regardless of whether short circuit > was used
should short circuit >
should short circuit negated >
should short circuit > when reification is used
should short circuit > even when the right hand side is a fixnum
should raise error when the > right hand side is of illegal type
should give the same solution regardless of whether short circuit >= was used
should short circuit >=
should short circuit negated >=
should short circuit >= when reification is used
should short circuit >= even when the right hand side is a fixnum
should raise error when the >= right hand side is of illegal type
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should short circuit negated ==
should short circuit == when reification is used
should short circuit == even when the right hand side is a fixnum
should raise error when the == right hand side is of illegal type
should give the same solution regardless of whether short circuit < was used
should short circuit <
should short circuit negated <
should short circuit < when reification is used
should short circuit < even when the right hand side is a fixnum
should raise error when the < right hand side is of illegal type
should give the same solution regardless of whether short circuit <= was used
should short circuit <=
should short circuit negated <=
should short circuit <= when reification is used
should short circuit <= even when the right hand side is a fixnum
should raise error when the <= right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Distinct
should constrain variables to be distinct
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Distinct (with offsets)
should constrain variables to be distinct
should play nice with normal distinct
should raise error if the offsets are of an incorrect type
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Element
should not disturb normal array access
should constrain the selected element
should be translated into an element constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Equality
should constrain elements to be equal
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Extensional (tuple constraint)
should constrain the domain of all variables
should raise error if the right hand side is not an enumeration
should raise error if the right hand side does not contain tuples
should not allow negation
should not allow empty tuples
should not allow tuples of sizes other than the number of variables
should raise error if the right hand side does not contain tuples of correct type
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Extensional (regexp constraint)
should handle the any operation
should handle the any operator with nested expressions
should handle values grouped in a single array
should allow nested groups of values
should handle the repeat operation
should handle repeat operations that do not encase constant values in arrays
should handle nested repeat operations
should handle nested repeat operations (2)
should interpret the repeat operation with the last argument omitted as only giving a lower bound
should interpret the repeat operation with all but the first argument omitted as not giving any bound
should interpret the repeat operation with all but the first argument omitted as not giving any bound (2)
should translate at_most_once(reg) to repeat(reg, 0, 1)
should translate at_least_once(reg) to repeat(reg, 1)
should raise error if the right hand side is not an enumeration
should raise error if the right hand side does not a regexp of the right type
should raise error if the right hand side contains a nested element of an incorrect type
should raise error if the repeat operation is given arguments of incorrect type (2)
should raise error if the repeat operation is given arguments of incorrect type (3)
should raise error if the repeat operation is given arguments of incorrect type
should not allow negation
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Sort (without :as and :order)
should constraint variables to be sorted
should allow negation
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
should raise errors if parameters of the incorrect type are given
Gecode::IntEnum::Sort (with :as)
should constraint variables to be sorted
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Sort (with :order)
should constraint variables to be sorted with the specified indices
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::IntEnum::Sort (with :order and :as)
should constraint variables to be sorted with the specified indices
should raise errors if reification is used
should raise errors for unrecognized options
should translate propagation strength value
should translate propagation strength domain
should translate propagation strength default
should translate propagation strength bounds
should default to using default as propagation strength
should raise errors for unrecognized propagation strengths
should translate propagation kind speed
should translate propagation kind default
should translate propagation kind memory
should default to using default as propagation kind
should raise errors for unrecognized propagation kinds
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Operand
should raise error if #model is not defined
should raise error if #construct_receiver is not defined
Gecode::Int::IntOperand
should fall back to the underlying variable
should not shadow method missing
Gecode::Int::ShortCircuitEqualityOperand (not subclassed)
should raise error if #constrain_equal is called
Gecode::Int::ShortCircuitRelationsOperand (not subclassed)
should raise error if #constrain_equal is called
Gecode::IntEnum::IntEnumOperand
should fall back to the underlying enum
should not shadow method missing
Gecode::Bool::BoolOperand
should fall back to the underlying variable
should not shadow method missing
Gecode::Bool::ShortCircuitEqualityOperand (not subclassed)
should raise error if #constrain_equal is called
Gecode::BoolEnum::BoolEnumOperand
should fall back to the underlying enum
should not shadow method missing
Gecode::Set::SetOperand
should fall back to the underlying variable
should not shadow method missing
Gecode::Set::ShortCircuitEqualityOperand (not subclassed)
should raise error if #constrain_equal is called
Gecode::Set::ShortCircuitRelationsOperand (not subclassed)
should raise error if #constrain_equal is called
Gecode::SelectedSet::SelectedSetOperand
should raise error if set enum operand is not given
should raise error if set operand is not given
should not shadow method missing
Gecode::SetElements::SetElementsOperand
should raise error if set operand is not given
should not shadow method missing
Gecode::SetEnum::SetEnumOperand
should fall back to the underlying enum
should not shadow method missing
Gecode::FixnumEnum::FixnumEnumOperand
should raise error if constraint receiver is called
should fall back to the underlying enum
should not shadow method missing
operand combination
should allow placing constraints on complicated combinations of operands
should allow placing constraints on complicated combinations of operands (2)
Gecode::ReifiableConstraint
should fail disjunctions if neither side can be satisfied
should solve disjunctions
should fail conjunctions if one side can't be satisfied
should solve conjunctions
should handle the same variable being used multiple times
should handle nested operations
should handle negations
Gecode::SetEnum::Element (disjoint)
should constrain the selected sets to be disjoint
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::SelectedSet::Element (union)
should constrain the selected union of an enum of sets
should translate into a elements union constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::SetEnum::Element (intersection)
should constrain the selected intersection of an enum of sets
should translate into a elements intersection constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::SelectedSet::Element (intersection with universe)
should constrain the selected intersection of an enum of sets in a universe
should allow the universe to be specified as a range
should translate into a elements intersection constraint
should raise error if unknown options are specified
should raise error if the universe is of the wrong type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Cardinality (constraint)
should translate cardinality constraints with ranges
should translate cardinality constraints with three dot range domains
should constrain the cardinality of a set
should raise error if the right hand side is not a range
should not shadow the integer variable domain constrain
Gecode::Set::Cardinality (property)
should constrain the cardinality of a set
should constrain the cardinality of a set (2)
should constrain the cardinality of a set (3)
should translate into a cardinality constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Channel (set variable as lhs with bool enum)
should channel the bool enum with the set variable
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Set::Channel (bool enum as lhs with set variable)
should channel the bool enum with the set variable
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Set::Connection (min)
should constrain the min of a set
should translate into a min constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Connection (max)
should constrain the max of a set
should translate into a max constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Connection (sum)
should constrain the sum of a set
should translate into a weights constraint
should raise error if unsupported options is given
should raise error if multiple options are given
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Connection (sum with weights)
should constrain the sum of a set
should remove any elements not in the weight hash
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Connection (sum with substitutions)
should constrain the sum of a set
should not be allowed together with :weights option
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce int operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Domain (superset)
should translate superset with constant range to domain constraint
should translate superset with constant non-range to domain constraint
should translate superset with constant singleton to domain constraint
should raise error if the right hand side is not a constant set
should constrain the domain when superset is used
should constrain the domain when negated superset is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Domain (subset)
should translate subset with constant range to domain constraint
should translate subset with constant non-range to domain constraint
should translate subset with constant singleton to domain constraint
should raise error if the right hand side is not a constant set
should constrain the domain when subset is used
should constrain the domain when negated subset is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Domain (disjoint)
should translate disjoint with constant range to domain constraint
should translate disjoint with constant non-range to domain constraint
should translate disjoint with constant singleton to domain constraint
should raise error if the right hand side is not a constant set
should constrain the domain when disjoint is used
should constrain the domain when negated disjoint is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Domain (complement)
should translate complement with constant range to domain constraint
should translate complement with constant non-range to domain constraint
should translate complement with constant singleton to domain constraint
should raise error if the right hand side is not a constant set
should constrain the domain when complement is used
should constrain the domain when negated complement is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Domain (equality)
should translate equality with constant range to domain constraint
should translate equality with constant non-range to domain constraint
should translate equality with constant singleton to domain constraint
should constrain the domain with equality
should constrain the domain with inequality
should raise error if the right hand side is not a constant set
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Connection (include)
should constrain the variables to be included in the set
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::Set::Operation (disjoint_union with set variable)
should translate disjoint_union into an operation constraint
should constrain the disjoint_union of the sets with variable rhs
should constrain the disjoint_union of the sets when used with constant rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (minus with set variable)
should translate minus into an operation constraint
should constrain the minus of the sets with variable rhs
should constrain the minus of the sets when used with constant rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (intersection with set variable)
should translate intersection into an operation constraint
should constrain the intersection of the sets with variable rhs
should constrain the intersection of the sets when used with constant rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (union with set variable)
should translate union into an operation constraint
should constrain the union of the sets with variable rhs
should constrain the union of the sets when used with constant rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (disjoint_union with constant set)
should translate disjoint_union into an operation constraint
should constrain the disjoint_union of the sets with a variable rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (minus with constant set)
should translate minus into an operation constraint
should constrain the minus of the sets with a variable rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (intersection with constant set)
should translate intersection into an operation constraint
should constrain the intersection of the sets with a variable rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Operation (union with constant set)
should translate union into an operation constraint
should constrain the union of the sets with a variable rhs
should produce constraints when short circuited
should give the same solution regardless of whether short circuit superset was used
should short circuit superset
should not short circuit negated superset
should not short circuit reified superset
should short circuit superset even when the right hand side is a constant set
should raise error when the superset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit subset was used
should short circuit subset
should not short circuit negated subset
should not short circuit reified subset
should short circuit subset even when the right hand side is a constant set
should raise error when the subset right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit disjoint was used
should short circuit disjoint
should not short circuit negated disjoint
should not short circuit reified disjoint
should short circuit disjoint even when the right hand side is a constant set
should raise error when the disjoint right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit complement was used
should short circuit complement
should not short circuit negated complement
should not short circuit reified complement
should short circuit complement even when the right hand side is a constant set
should raise error when the complement right hand side is of illegal type
should produce constraints when short circuited
should give the same solution regardless of whether short circuit == was used
should short circuit ==
should not short circuit negated ==
should not short circuit reified ==
should short circuit == even when the right hand side is a constant set
should raise error when the == right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::Set::Relation (superset)
should correctly constrain the set when superset is used
should correctly constrain the set when negated superset is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Relation (subset)
should correctly constrain the set when subset is used
should correctly constrain the set when negated subset is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Relation (disjoint)
should correctly constrain the set when disjoint is used
should correctly constrain the set when negated disjoint is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Relation (complement)
should correctly constrain the set when complement is used
should correctly constrain the set when negated complement is used
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::Set::Relation (equality)
should constrain sets to be equal
should constrain sets to not be equal when negated
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should translate reification
should translate reification with arbitrary bool operand
should raise errors for reification variables of incorrect type
Gecode::SetElements::Relation (> with int op)
should constrain the elements of the set when > is used
should constrain the elements of the set when negated > is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (>= with int op)
should constrain the elements of the set when >= is used
should constrain the elements of the set when negated >= is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (== with int op)
should constrain the elements of the set when == is used
should constrain the elements of the set when negated == is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (< with int op)
should constrain the elements of the set when < is used
should constrain the elements of the set when negated < is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (<= with int op)
should constrain the elements of the set when <= is used
should constrain the elements of the set when negated <= is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (> with fixnum)
should constrain the elements of the set when > is used
should constrain the elements of the set when negated > is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (>= with fixnum)
should constrain the elements of the set when >= is used
should constrain the elements of the set when negated >= is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (== with fixnum)
should constrain the elements of the set when == is used
should constrain the elements of the set when negated == is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (< with fixnum)
should constrain the elements of the set when < is used
should constrain the elements of the set when negated < is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetElements::Relation (<= with fixnum)
should constrain the elements of the set when <= is used
should constrain the elements of the set when negated <= is used
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
Gecode::SetEnum::Channel::IntEnumChannelConstraint (channel with set as right hand side)
should constrain variables to be channelled
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::SetEnum::Channel::IntEnumChannelConstraint (channel with set as left hand side)
should constrain variables to be channelled
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::SetEnum::Distinct (at most one)
should translate into a atmostOne constraint
should constrain sets to have at most one element in common
should raise error if :size is not specified
should not accept reification option
should not accept strength option
should not accept kind option
should raise errors for unrecognized options
should raise errors if parameters of the incorrect type are given
should raise errors if negation is used
Gecode::SetEnum::Element (int operand)
should not disturb normal array access
should constrain the specified element of an enum of sets
should translate into a element constraint
should not disturb normal array access
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::SetEnum::Element (set operand)
should produce a selected set operand
Gecode::SetEnum::Operation (union)
should constrain the union of the sets
should translate into an operand constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::SetEnum::Operation (intersection)
should constrain the intersection of the sets
should translate into an operand constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Gecode::SetEnum::Operation (disjoint union)
should constrain the disjoint union of the sets
should constrain the disjoint union of the sets (2)
should translate into an operand constraint
should produce constraints when short circuited
should give the same solution regardless of whether short circuit was used
should short circuit equality
should not short circuit when negation is used
should not short circuit when reification is used
should not short circuit when the right hand side is not a operand
should not short circuit when equality is not used
should raise error when the right hand side is of illegal type
should produce set operand
should raise errors if parameters of the incorrect type are given
Interface installed on win32 systems
should be able to load the libraries
Gecode::Util::EnumMatrix
should be enumerable
should produce rows that are enumerable
should produce columns that are enumerable
should produce submatrices that are enumerable
Gecode::Util::EnumMatrix (when wrapped)
should produce rows that are wrapped
should produce columns that are enumerable
should produce submatrices that are enumerable
Gecode::Mixin (enum wrapping)
should only allow enumerables to be wrapped
should allow enumerables of bool variables to be wrapped
should allow enumerables of bool operands to be wrapped
should allow enumerables of int variables to be wrapped
should allow enumerables of int operands to be wrapped
should allow enumerables of set variables to be wrapped
should allow enumerables of set operands to be wrapped
should allow enumerables of fixnums to be wrapped
should not allow empty enumerables to be wrapped
should not allow wrapping a wrapped enumerable
should not allow enumerables without variables or fixnums to be wrapped
should not allow enumerables with only some variables to be wrapped
should not allow enumerables with mixed types of variables to be wrapped
Gecode::IntEnumMethods
should convert to an int var array
should compute the smallest domain range
should define #to_int_enum
Gecode::BoolEnumMethods
should convert to a bool var array
should define #to_bool_enum
Gecode::SetEnumMethods
should convert to a set var array
should compute the smallest upper bound union range
should define #to_set_enum
Gecode::FixnumEnumMethods
should compute the smallest domain range
should define #to_fixnum_enum
Example (minesweeper.rb)
should not output errors
Example (queens.rb)
should not output errors
Example (send_most_money.rb)
should not output errors
Example (sudoku-set.rb)
should not output errors
Example (equation_system.rb)
should not output errors
Example (send_more_money.rb)
should not output errors
Example (magic_sequence.rb)
should not output errors
Example (sudoku.rb)
should not output errors
Example (square_tiling.rb)
should not output errors
Example (nonogram.rb)
should not output errors
Example (survo.rb)
should not output errors
Gecode::IntVar (with range domain of size > 1)
should not be assigned
should have a range domain
should raise error when trying to access assigned value
should have min equal to the lower domain bound
should have max equal to the upper domain bound
should have size equal to the domain size
should contain every element in its domain
should not contain elements outside its domain
should have a width equal to the domain width
should give a NoMethodError when calling a method that doesn't exist
should have a zero degree
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::IntVar (defined with three-dot range)
should have min equal to the lower domain bound
should have max equal to the upper domain bound
should have size equal to the domain size
should contain every element in its domain
should not contain elements outside its domain
should have a width equal to the domain width
should give a NoMethodError when calling a method that doesn't exist
should have a zero degree
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::IntVar (with non-range domain of size > 1)
should not be assigned
should not be a range domain
should not contain the domain's holes
should have min equal to the lower domain bound
should have max equal to the upper domain bound
should have size equal to the domain size
should contain every element in its domain
should not contain elements outside its domain
should have a width equal to the domain width
should give a NoMethodError when calling a method that doesn't exist
should have a zero degree
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::IntVar (with a domain of size 1)
should be assigned
should be a range domain
should have min equal to the lower domain bound
should have max equal to the upper domain bound
should have size equal to the domain size
should contain every element in its domain
should not contain elements outside its domain
should have a width equal to the domain width
should give a NoMethodError when calling a method that doesn't exist
should have a zero degree
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::IntVar (assigned)
should be assigned
should give the assigned number when inspecting
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::IntVar (not assigned)
should not be assigned
should give the domain range when inspecting
should return the correct domain through #domain
should implement #model
should implement #to_int_var
should implement #must
Gecode::LoggingLayer
shouldn't interfere with calls through Gecode::Raw
Gecode::Mixin (mixed into a class)
should respond to everything that Gecode::Model does
should solve a sample problem
should not mess with classes defining method missing
should not mess with classes defining method missing (2)
Gecode::Mixin (integer creation)
should allow the creation of int variables with range
should allow the creation of int variables without specified domain
should allow the creation of int variables with non-range domains
should allow the creation of int variables with single element domains
should allow the creation of int-var arrays with range domains
should allow the creation of int-var arrays with non-range domains
should allow the creation of int-var arrays without specified domain
should allow the creation of int-var matrices with range domains
should allow the creation of int-var matrices with non-range domains
should allow the creation of int-var matrices without specified domain
should raise error if the domain is of incorrect type
should gracefully GC a variable that was never accessed
Gecode::Mixin (bool creation)
should allow the creation of boolean variables
should allow the creation of arrays of boolean variables
should allow the creation of matrices of boolean variables
should gracefully GC a variable that was never accessed
Gecode::Mixin (set creation)
should allow the creation of set variables without specified bounds
should allow the creation of set variables with glb range and lub range
should allow the creation of set variables with glb enum and lub range
should allow the creation of set variables with glb range and lub enum
should allow the creation of set variables with glb enum and lub enum
should allow the creation of set variables with specified lower cardinality bound
should allow the creation of set variables with specified cardinality range
should allow the creation of arrays of set variables
should allow the creation of arrays of set variables without specified bounds
should allow the creation of matrices of set variables
should allow the creation of matrices of set variables without specified bounds
should raise error if glb and lub are not valid when they are given as range
should raise error if glb and lub are not valid when one is given as enum
should raise error if glb and lub are not valid when both are given as enums
should raise error if the glb and lub are of incorrect type
should gracefully GC a variable that was never accessed
Gecode::Mixin (space access restriction)
should raise error if not allowed to access space
should not raise error because of space restriction if allowed to access space
Gecode::Mixin (accessible variable creation)
should allow creation of named variable using #foo_is_a
should allow creation of named variable using #foo_is_an
should only allow one argument to be given to #foo_is_a
should only define the variable in the current instance
should raise error if a method would be overwritten
should raise error if an instance variable would be overwritten
Gecode (Model sugar)
should provide #solve as sugar for constructing a model and running solve!
should provide #maximize as sugar for constructing a model and running maximize!
should provide #minimize as sugar for constructing a model and running minimize!
Gecode::Mixin (with multiple solutions)
should pass a solution to the block given in #solution
should update the search statistics before yielding to #solution
should only evaluate the block for one solution in #solution
should return the result of the block when calling #solution
should pass every solution to #each_solution
should update the search statistics before yielding to #each_solution
Gecode::Mixin (after #solve!)
should have updated the variables domains
should have updated variables in arrays
should have updated variables in hashes
should have updated variables in nested enums
should have updated the search statistics
Gecode::Mixin (after #reset!)
should have reset variables
should have reset variables in nested enums
should have cleared the search statistics
Gecode::Mixin (after #solution)
should have reset variables
should have reset variables in nested enums
should have cleared the search statistics
Gecode::Mixin (after #each_solution)
should have reset variables
should have reset variables in nested enums
should have cleared the search statistics
Gecode::Mixin (without solution)
should return nil when calling #solution
should not yield anything to #each_solution
should raise NoSolutionError when calling #solve!
should raise NoSolutionError when calling #optimize!
should raise NoSolutionError when calling #minimize!
should raise NoSolutionError when calling #maximize!
Gecode::Mixin (without constraints)
should produce a solution
Gecode::Mixin (optimization search)
should optimize the solution
should not be bothered by garbage collecting
should raise error if no constrain proc has been defined
should not have problems with variables being created in the optimization block
should not have problems with variables being created in the optimization block (2)
should update the search statistics
Gecode::Mixin (single variable minimization)
should support having the variable given as a symbol
should support having the variable given as a string
should raise error if is given a non-existing method
should raise error if is given a method that does not return an integer variable
should update the search statistics
Gecode::Mixin (single variable maximization)
should support having the variable given as a symbol
should support having the variable given as a string
should raise error if is given a non-existing method
should raise error if is given a method that does not return an integer variable
should update the search statistics
Gecode::Mixin (with time limitations)
should not time out problems that finish within the time limitation
should time out problems that do not finish within the time limitation
should raise error if an unrecognised option is passed
Gecode::SelectedSet::SelectedSetOperand
should implement #model
should implement #to_selected_set
should implement #must
Gecode::SelectedSet::SelectedSetOperand
should implement #model
should implement #to_set_elements
should implement #must
should be produces by SetOperand#elements
Gecode::SetVar (not assigned)
should not be assigned
should give glb and lub ranges when inspecting
should allow inspection even when the bounds are too large to display
should report the correct bounds
should report correct bounds on upper bound
should report correct bounds on lower bound
should raise error when trying to access assigned value
should not raise error when enumerating over bound multiple times
should implement #model
should implement #to_set_var
should implement #must
Gecode::SetVar (assigned)
should be assigned
should give it's value when inspecting
should report the correct bounds
should allow inspection even when the bounds are too large to display
should implement #model
should implement #to_set_var
should implement #must