#!/usr/bin/ruby

$:.unshift File.join(File.dirname(__FILE__), "..", "lib")

require 'test/unit'
require 'AllDifferentConstraint'
require 'Variable'
require 'Domain'

module ConstraintSolver
    class AllDifferentConstraintTest < Test::Unit::TestCase
	def setup
	    @x = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set))
	    @y = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
	    @z = Variable.new("z", Domain.new([ 1, 2, 3 ].to_set))
	    @constraint = AllDifferentConstraint.new([ @x, @y, @z ])
	end

	def testConstructor
	    assert_raise(ArgumentError) { AllDifferentConstraint.new }
	    assert_raise(ArgumentError) { AllDifferentConstraint.new([]) }
	    assert_raise(ArgumentError) { AllDifferentConstraint.new([ @x ]) }
	    assert_nothing_raised { AllDifferentConstraint.new([ @x, @y, @z ]) }
	    assert_nothing_raised { AllDifferentConstraint.new([ @x, @y, @z ], 0) }
	end

	def testAssigned
	    assert_equal(false, @constraint.allAssigned?)
	    @y.value = 1
	    @z.value = 1
	    assert_equal(false, @constraint.allAssigned?)
	    @x.value = 1
	    assert_equal(true, @constraint.allAssigned?)
	    @x.reset
	    @y.reset
	    @z.reset
	end

	def testInclude
	    assert_equal(true, @constraint.include?(@x))
	    assert_equal(true, @constraint.include?(@y))
	    assert_equal(true, @constraint.include?(@z))
	    assert_equal(false, @constraint.include?(Variable.new("foobar", 1)))
	end

	def testEquals
	    assert_not_equal(AllDifferentConstraint.new([ @x, @y ]), @constraint)
	    assert_equal(AllDifferentConstraint.new([ @x, @y, @z ]), @constraint)
	end

	def testHolds
	    @x.value = 1
	    @y.value = 2
	    @z.value = 2
	    assert_equal(false, @constraint.holds?)
	    @z.value = 3
	    assert_equal(true, @constraint.holds?)
	    @constraint.variables.each { |var| var.reset }
	end

	def testRevise_decomposed_local
	    assert_equal([ [], 0, false ], @constraint.revise_decomposed_local)
	    @x.value = 1
	    assert_equal([ [ @y, @z ], 0, false ], @constraint.revise_decomposed_local)
	    assert_equal([ 2, 3 ].to_set, @y.values)
	    assert_equal([ 2, 3 ].to_set, @z.values)
	    @x.reset

	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
	    z = Variable.new("z", Domain.new([ 2, 3 ].to_set))
	    constraint = AllDifferentConstraint.new([ x, y, z ])
	    assert_equal([ [], 0, false ], constraint.revise_decomposed_local)
	    assert_equal([ 1, 3 ].to_set, x.values)
	    assert_equal([ 2, 3 ].to_set, y.values)
	    assert_equal([ 2, 3 ].to_set, z.values)

	    a = Variable.new("a", Domain.new([ 1 ].to_set))
	    b = Variable.new("b", Domain.new([ 1, 2 ].to_set))
	    c = Variable.new("c", Domain.new([ 1, 2, 3 ].to_set))
	    constraint = AllDifferentConstraint.new([ a, b, c ])
	    assert_equal([ [ b, c, c ], 0, false ], constraint.revise_decomposed_local)
	    assert_equal([ 1 ].to_set, a.values)
	    assert_equal([ 2 ].to_set, b.values)
	    assert_equal([ 3 ].to_set, c.values)
	end

	def testDomainWipeout_decomposed_local
	    x = Variable.new("x", Domain.new([ 1, 2, 3 ].to_set))
	    y = Variable.new("y", Domain.new([ 1, 2, 3 ].to_set))
	    z = Variable.new("z", Domain.new([ 1, 2, 3 ].to_set))
	    a = Variable.new("a", Domain.new([ 1, 2, 3 ].to_set))
	    constraint = AllDifferentConstraint.new([ x, y, z, a ])
	    a.value = 1
	    assert_equal([ [ x, y, z ], 0, true ], constraint.revise_decomposed_local)
	end

	def testRevise_hyperarc
	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
	    z = Variable.new("z", Domain.new([ 2, 3 ].to_set))
	    constraint = AllDifferentConstraint.new([ x, y, z ])
	    assert_equal([ [ x ], 0, false ], constraint.revise_hyperarc)
	    assert_equal([ 1 ].to_set, x.values)
	    assert_equal([ 2, 3 ].to_set, y.values)
	    assert_equal([ 2, 3 ].to_set, z.values)

	    a = Variable.new("a", Domain.new([ 1 ].to_set))
	    b = Variable.new("b", Domain.new([ 1, 2 ].to_set))
	    c = Variable.new("c", Domain.new([ 1, 2, 3 ].to_set))
	    constraint = AllDifferentConstraint.new([ a, b, c ])
	    revisedVariables, checks, wipeout = constraint.revise_hyperarc
	    assert_equal(false, wipeout)
	    assert_equal(Set.new, [ b, c ].to_set - revisedVariables.to_set)
	    assert_equal(0, checks)
	    assert_equal([ 1 ].to_set, a.values)
	    assert_equal([ 2 ].to_set, b.values)
	    assert_equal([ 3 ].to_set, c.values)
	    
	    assert_equal([ [], 0, false ], constraint.revise_hyperarc)

	    x = Variable.new("x", Domain.new([ 1, 3 ].to_set))
	    y = Variable.new("y", Domain.new([ 2, 3 ].to_set))
	    z = Variable.new("z", Domain.new([ 2, 3, 4 ].to_set))
	    constraint = AllDifferentConstraint.new([ x, y, z ])
	    assert_equal([ [], 0, false ], constraint.revise_hyperarc)
	    assert_equal([ 1, 3 ].to_set, x.values)
	    assert_equal([ 2, 3 ].to_set, y.values)
	    assert_equal([ 2, 3, 4 ].to_set, z.values)
	end

	def testDomainWipeout_hyperarc
	    x = Variable.new("x", Domain.new([ 1, 2 ].to_set))
	    y = Variable.new("y", Domain.new([ 1, 2 ].to_set))
	    z = Variable.new("z", Domain.new([ 1, 2 ].to_set))
	    constraint = AllDifferentConstraint.new([ x, y, z ])
	    assert_equal([ [], 0, true ], constraint.revise_hyperarc)
	end
    end
end