- 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