def test_compute_constraints_detect_invalid_constraints(self):
"""
Test that, function should raise an exception, if there is invalid_constraints
"""
parameters = [3, 3, 3]
constraints = {(Pair(0, 0), ), (Pair(0, 1), ), (Pair(0, 2), )}
solver = Solver([], [])
solver.data = parameters
solver.constraints = constraints
solver.read_constraints()
self.assertRaises(ValueError, solver.compute_constraints)
def setUp(self):
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(1, 1), Pair(2, 0)),
(Pair(0, 2), Pair(3, 2))}
t_value = 2
self.cit = Cit(parameters, t_value, constraints)
def test_simplify_constraints_constraints_with_simplification(self):
"""
Test that, function do not delete important constraints
"""
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(2, 0), Pair(1, 1)),
(Pair(0, 2), Pair(2, 0)), (Pair(2, 0), )}
solver = Solver([], [])
solver.data = parameters
solver.constraints = constraints
solver.read_constraints()
solver.simplify_constraints()
expectation = {(Pair(2, 0), )}
self.assertEqual(
solver.constraints, expectation,
"simplify_constraints deleted some important constraints")
def test_solver_constraints_without_simplification(self):
"""
Test that, solver do not delete important constraints
"""
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(1, 1), Pair(2, 0)),
(Pair(0, 2), Pair(3, 2))}
solver = Solver(parameters, constraints)
self.assertEqual(solver.constraints, constraints,
"solver deleted some important constraints")
def test_initialization(self):
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(1, 1), Pair(2, 0)),
(Pair(0, 2), Pair(3, 2))}
t_value = 2
solver = Solver(parameters, constraints)
combination_matrix = CombinationMatrix(parameters, t_value)
solver.clean_hash_table(combination_matrix, t_value)
cit = Cit(parameters, t_value, constraints)
self.assertEqual(combination_matrix, cit.combination_matrix,
"The initialization of cit algorithm is wrong")
def test_solver_without_secrete_constraints(self):
"""
Test that, solver didn't change constraints if there isn't any secret constraint
"""
parameters = [3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)), (Pair(0, 1), Pair(1, 1)),
(Pair(1, 0), Pair(2, 0))}
solver = Solver(parameters, constraints)
self.assertEqual(
solver.constraints, constraints,
"solver change constraints without secret "
"constraint")
def test_compute_constraints_without_secret_constraint(self):
"""
Test that, function shouldn't change constraints if there isn't any secret constraint
"""
parameters = [3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)), (Pair(0, 1), Pair(1, 1)),
(Pair(1, 0), Pair(2, 0))}
solver = Solver([], [])
solver.data = parameters
solver.constraints = constraints
solver.read_constraints()
solver.compute_constraints()
self.assertEqual(
solver.constraints, constraints,
"compute_constraints change constraints without secret "
"constraint")
def test_compute_constraints_new_constraint_with_more_than_one_value_for_one_parameter(
self):
"""
Test that, function shouldn't change constraints. It founds new constraint,
but the constraint has one parameter with two values. This means that it isn't secreted constraint.
"""
parameters = [3, 3, 3]
constraints = {(Pair(0, 0), Pair(1, 0)), (Pair(0, 1), Pair(1, 1)),
(Pair(1, 2), Pair(2, 0))}
solver = Solver([], [])
solver.data = parameters
solver.constraints = constraints
solver.read_constraints()
solver.compute_constraints()
self.assertEqual(
solver.constraints, constraints,
"compute_constraints change constraints without secret "
"constraint")
def test_compute_constraints_with_one_secrete_constraint(self):
"""
Test that, function should find new constraint
"""
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(1, 1), Pair(2, 0)),
(Pair(0, 2), Pair(3, 2))}
solver = Solver([], [])
solver.data = parameters
solver.constraints = constraints
solver.read_constraints()
solver.compute_constraints()
expectation = {(Pair(0, 0), Pair(2, 0)),
(Pair(0, 1), Pair(1, 1), Pair(2, 0)),
(Pair(0, 2), Pair(3, 2)),
(Pair(1, 1), Pair(2, 0), Pair(3, 2))}
self.assertEqual(solver.constraints, expectation,
"compute_constraints didn't find secret constraints")
def test_solver_constraints_with_simplification_and_secrete(self):
"""
Test that, Minimum forbidden tuple algorithm can find and simplify constraints
"""
parameters = [3, 3, 3, 3]
constraints = {(Pair(0, 0), Pair(1, 0)), (Pair(0, 0), Pair(1, 2)),
(Pair(0, 1), Pair(3, 0)), (Pair(0, 2), Pair(3, 0)),
(Pair(1, 1), Pair(3, 0))}
solver = Solver(parameters, constraints)
expectation = {(Pair(0, 0), Pair(1, 0)), (Pair(0, 0), Pair(1, 2)),
(Pair(3, 0), )}
self.assertEqual(solver.constraints, expectation,
"solver can not compute and simplify constraints")