# File test/ConstraintSolverTest.rb, line 13
        def setup
            domain = Domain.new([ 1, 2 ].to_set)
            @var1 = Variable.new("x", domain, nil, 1)
            @var2 = Variable.new("y", domain.clone, nil, 2)
            @var3 = Variable.new("z", domain.clone, nil, 3)
            relation = BinaryRelation.new("!=")
            constraint1 = BinaryConstraint.new(@var1, @var2, relation)
            constraint2 = BinaryConstraint.new(@var1, @var3, relation.clone)
            constraint3 = BinaryConstraint.new(@var2, @var3, relation.clone)
            @meritMap = { 1 => 2, 2 => 1 }
            @solvableProblem = Problem.new([ @var1, @var2 ], ConstraintList.new([ constraint1 ]), @meritMap)
            @unsolvableProblem = Problem.new([ @var1, @var2, @var3 ],
                                             ConstraintList.new([ constraint1, constraint2, constraint3 ]))
            @solver = ConstraintSolver.new
        end

# File test/ConstraintSolverTest.rb, line 60
        def testAllDifferentProblem
            domain = Domain.new([ 1, 2, 3 ].to_set)
            x = Variable.new("x", domain)
            y = Variable.new("y", domain.clone)
            z = Variable.new("z", domain.clone)
            constraint = AllDifferentConstraint.new([ x, y, z ])
            #@solver.log.outputters = Outputter.stderr
            solutions, nodeChecks, constraintChecks = @solver.solve(Problem.new([ x, y, z ], constraint))
            assert_equal(6, solutions.size)
            assert_equal(15, nodeChecks)
            #assert_equal(27, constraintChecks)
        end

# File test/ConstraintSolverTest.rb, line 73
        def testAllDifferentWithoutAllDifferent
            domain = Domain.new([ 1, 2, 3 ].to_set)
            x = Variable.new("x", domain)
            y = Variable.new("y", domain.clone)
            z = Variable.new("z", domain.clone)
            relation = BinaryRelation.new("!=")
            c1 = BinaryConstraint.new(x, y, relation)
            c2 = BinaryConstraint.new(x, z, relation.clone)
            c3 = BinaryConstraint.new(y, z, relation.clone)
            #@solver.log.outputters = Outputter.stderr
            solutions, nodeChecks, constraintChecks =
                @solver.solve(Problem.new([ x, y, z ], ConstraintList.new([ c1, c2, c3 ]))) 
            assert_equal(6, solutions.size)
            assert_equal(15, nodeChecks)
            assert_equal(48, constraintChecks)
        end

# File test/ConstraintSolverTest.rb, line 29
        def testConstructor
            assert_nothing_raised { ConstraintSolver.new }
        end

# File test/ConstraintSolverTest.rb, line 33
        def testSolvableProblem
            #@solver.log.outputters = Outputter.stderr
            solutions, nodeChecks, constraintChecks = @solver.solve(@solvableProblem)
            assert_equal(false, solutions.empty?)
            assert_equal(2, solutions.size)
            @var1.value = 2
            @var2.value = 1
            assert_equal(Solution.new([ @var1, @var2 ], @meritMap), solutions[0])
            assert_equal(5, solutions[0].merit)
            @var1.value = 1
            @var2.value = 2
            assert_equal(Solution.new([ @var1, @var2 ], @meritMap), solutions[1])
            assert_equal(4, solutions[1].merit)
            @var1.reset
            @var2.reset
            assert_equal(4, nodeChecks)
            assert_equal(4, constraintChecks)
        end

# File test/ConstraintSolverTest.rb, line 52
        def testUnsolvableProblem
            #@solver.log.outputters = Outputter.stderr
            solutions, nodeChecks, constraintChecks = @solver.solve(@unsolvableProblem)
            assert_equal(true, solutions.empty?)
            assert_equal(2, nodeChecks)
            assert_equal(8, constraintChecks)
        end

# File test/ConstraintSolverTest.rb, line 90
        def testVariableAndValueOrdering
            domain = Domain.new([ "foo", "bar", "foobar" ].to_set)
            meritMap = { "foo" => 1, "bar" => 2, "foobar" => 3 }
            x = Variable.new("x", domain, nil, 1)
            y = Variable.new("y", domain.clone, nil, 2)
            c = AllDifferentConstraint.new([ x, y ])
            #@solver.log.outputters = Outputter.stderr
            solutions = @solver.solve(Problem.new([ x, y ], c, meritMap))[0]
            assert_equal(6, solutions.size)
            assert_equal(8, solutions[0].merit)
            assert_equal(7, solutions[1].merit)
            assert_equal(7, solutions[2].merit)
            assert_equal(5, solutions[3].merit)
            assert_equal(5, solutions[4].merit)
            assert_equal(4, solutions[5].merit)
        end