def setUp(self): self.build_mvine = Mvine.build Mvine.build = Mock(return_value = True) self.cs = ConstraintSystem() self.cs._propagate_walk_strength = Mock(return_value = True) self.cs.collect_unenforced = Mock(return_value = True) self.f = Fixture()
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30),
self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0),
self.constraint_system)
mMp = Method([self.point1, self.point2], [self.midpoint],
lambda p1, p2: Point((p1.X + p2.X) / 2,
(p1.Y + p2.Y) / 2))
mP1 = Method([self.midpoint, self.point2], [self.point1],
lambda mp, p2: Point((2 * mp.X - p2.X),
(2 * mp.Y - p2.Y)))
mP2 = Method([self.midpoint, self.point1], [self.point2],
lambda mp, p1: Point((2 * mp.X - p1.X),
(2 * mp.Y - p1.Y)))
constraint = Constraint(
lambda point1, point2, midpoint: midpoint.is_midpoint(
point1, point2), Strength.STRONG,
[self.point1, self.point2, self.midpoint], [mMp, mP1, mP2])
self.constraint_system.add_constraint(constraint)
def test_max_out(self):
cs = ConstraintSystem()
v1 = Variable("v1", 13, cs)
v2 = Variable("v2", 12, cs)
method = Method(v1, v2, lambda v1: v1 - 1)
self.assertEqual(Strength.WEAKEST, cs.max_out(method, [v1]))
def test_max_out(self):
cs = ConstraintSystem()
v1 = Variable("v1", 13, cs)
v2 = Variable("v2", 12, cs)
method = Method(v1, v2, lambda v1: v1 - 1)
self.assertEqual(Strength.WEAKEST, cs._max_out(method, [v1]))
class Fixture:
def __init__(self):
self.constraint_system = ConstraintSystem()
self.a = Variable("a", 1, self.constraint_system)
self.b = Variable("b", 2, self.constraint_system)
self.c = Variable("c", 3, self.constraint_system)
self.a_equals_b_plus_2_constraint = self.create_a_equals_b_plus_2_constraint()
self.a_equals_c_minus_1_constraint = self.create_a_equals_c_minus_1_constraint()
self.a_plus_b_equals_c_constraint = self.create_a_plus_b_equals_c_constraint()
def create_a_equals_b_plus_2_constraint(self):
mA = Method([self.a], [self.b],
lambda a: a - 2)
mB = Method([self.b], [self.a],
lambda b: b + 2)
return Constraint(
lambda a, b: a == b + 2,
Strength.STRONG,
[self.a, self.b],
[mA, mB])
def create_a_equals_c_minus_1_constraint(self):
mA = Method([self.a], [self.c],
lambda a: c - 1)
mC = Method([self.c], [self.a],
lambda c: a + 1)
return Constraint(
lambda a, c: a == c - 1,
Strength.STRONG,
[self.a, self.c],
[mA, mC])
def create_a_plus_b_equals_c_constraint(self):
mC = Method([self.a,self.b], [self.c],
lambda a, b: a + b)
mB = Method([self.a,self.c], [self.b],
lambda a, c: c - a)
mA = Method([self.b, self.c], [self.a],
lambda b, c: c - b)
return Constraint(
lambda a, b, c: a + b == c,
Strength.STRONG,
[self.a, self.b, self.c],
[mA, mB, mC])
def simple_constraint_system(self):
self.constraint_system.add_constraint(self.a_equals_b_plus_2_contraint)
self.constraint_system.add_constraint(self.a_equals_c_minus_1_contraint)
return self.constraint_system
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30), self.constraint_system)
self.point3 = Variable("Point 3", Point(50, 20), self.constraint_system)
self.point4 = Variable("Point 4", Point(100, 30), self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0), self.constraint_system)
mpmp3p4 = Method([self.midpoint, self.point3, self.point4], [self.point1, self.point2],
lambda pm, p3, p4: (
Point(
pm.X - (p4.X - p3.X),
pm.Y - (p4.Y - p3.Y)
),
Point(
pm.X + (p4.X - p3.X),
pm.Y + (p4.Y - p3.Y)
)
)
)
mp1pmp3 = Method([self.point1, self.midpoint, self.point3], [self.point2, self.point4],
lambda p1, pm, p3: (
Point(
2 * pm.X - p1.X,
2 * pm.Y - p1.Y
),
Point(
p3.X + (pm.X - p1.X),
p3.Y + (pm.Y - p1.Y)
)
)
)
mpmp2p4 = Method([self.midpoint, self.point2, self.point4], [self.point1, self.point3],
lambda pm, p2, p4: (
Point(
2 * pm.X - p2.X,
2 * pm.Y - p2.Y
),
Point(
p4.X + (pm.X - p2.X),
p4.Y + (pm.Y - p2.Y)
)
)
)
constraint = Constraint(
lambda p1, p2, p3, p4, pm: pm.is_midpoint(p1, p2) and
p1.distance(pm) == p3.distance(p4),
Strength.STRONG,
[self.point1, self.point2, self.point3, self.point4, self.midpoint],
[mpmp3p4, mp1pmp3, mpmp2p4])
self.constraint_system.add_constraint(constraint)
self.point3.stay()
self.point4.stay()
class ConstraintTests(TestCase):
def setUp(self):
self.constraint_system = ConstraintSystem()
self.variables = self.constraint_system.create_variables(
["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.variables
method1_2 = Method(self.v1, self.v2, lambda x: x // 2)
method1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.constraint = Constraint(lambda v1, v2, v3: True, Strength.STRONG,
self.variables, [method1_3, method1_2])
self.constraint_system.add_constraint(self.constraint)
def tearDown(self):
pass
def test_adding_enforced_to_pplan(self):
self.assertIsNone(self.constraint.mark)
mark = self.constraint_system.marker.new_mark()
pplan = self.constraint.add_to_pplan([], mark)
self.assertEqual([self.constraint], pplan)
self.assertEqual(mark, self.constraint.mark)
def test_adding_unenforced_to_pplan(self):
self.constraint.selected_method = None
self.assertIsNone(self.constraint.mark)
pplan = self.constraint.add_to_pplan(
[], self.constraint_system.marker.new_mark())
self.assertEqual([], pplan)
self.assertIsNone(self.constraint.mark)
def test_adding_with_the_same_mark(self):
mark = self.constraint_system.marker.new_mark()
self.constraint.mark = mark
pplan = self.constraint.add_to_pplan([], mark)
self.assertEqual([], pplan)
self.assertEqual(mark, self.constraint.mark)
def test_adding_with_other_mark(self):
mark1 = self.constraint_system.marker.new_mark()
mark2 = self.constraint_system.marker.new_mark()
self.constraint.mark = mark1
pplan = self.constraint.add_to_pplan([], mark2)
self.assertEqual([self.constraint], pplan)
self.assertEqual(mark2, self.constraint.mark)
def setUp(self):
self.constraint_system = ConstraintSystem()
self.variables = self.constraint_system.create_variables(
["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.variables
method1_2 = Method(self.v1, self.v2, lambda x: x // 2)
method1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.constraint = Constraint(lambda v1, v2, v3: True, Strength.STRONG,
self.variables, [method1_3, method1_2])
self.constraint_system.add_constraint(self.constraint)
def __init__(self):
self.constraint_system = ConstraintSystem()
self.a = Variable("a", 1, self.constraint_system)
self.b = Variable("b", 2, self.constraint_system)
self.c = Variable("c", 3, self.constraint_system)
self.a_equals_b_plus_2_constraint = self.create_a_equals_b_plus_2_constraint(
)
self.a_equals_c_minus_1_constraint = self.create_a_equals_c_minus_1_constraint(
)
self.a_plus_b_equals_c_constraint = self.create_a_plus_b_equals_c_constraint(
)
class ConstraintTests(TestCase):
def setUp(self):
self.constraint_system = ConstraintSystem()
self.variables = self.constraint_system.create_variables(["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.variables
method1_2 = Method(self.v1, self.v2, lambda x: x // 2)
method1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.constraint = Constraint(lambda v1, v2, v3: True, Strength.STRONG, self.variables, [method1_3, method1_2])
self.constraint_system.add_constraint(self.constraint)
def tearDown(self):
pass
def test_adding_enforced_to_pplan(self):
self.assertIsNone(self.constraint.mark)
mark = self.constraint_system.marker.new_mark()
pplan = self.constraint.add_to_pplan([], mark)
self.assertEqual([self.constraint], pplan)
self.assertEqual(mark, self.constraint.mark)
def test_adding_unenforced_to_pplan(self):
self.constraint.selected_method = None
self.assertIsNone(self.constraint.mark)
pplan = self.constraint.add_to_pplan([], self.constraint_system.marker.new_mark())
self.assertEqual([], pplan)
self.assertIsNone(self.constraint.mark)
def test_adding_with_the_same_mark(self):
mark = self.constraint_system.marker.new_mark()
self.constraint.mark = mark
pplan = self.constraint.add_to_pplan([], mark)
self.assertEqual([], pplan)
self.assertEqual(mark, self.constraint.mark)
def test_adding_with_other_mark(self):
mark1 = self.constraint_system.marker.new_mark()
mark2 = self.constraint_system.marker.new_mark()
self.constraint.mark = mark1
pplan = self.constraint.add_to_pplan([], mark2)
self.assertEqual([self.constraint], pplan)
self.assertEqual(mark2, self.constraint.mark)
def setUp(self): self.build_mvine = Mvine.build Mvine.build = Mock(return_value = True) self.cs = ConstraintSystem() self.cs.propagate_walk_strength = Mock(return_value = True) self.cs.collect_unenforced = Mock(return_value = True) self.f = Fixture()
class Fixture:
def __init__(self):
self.constraint_system = ConstraintSystem()
self.a = Variable("a", 1, self.constraint_system)
self.b = Variable("b", 2, self.constraint_system)
self.c = Variable("c", 3, self.constraint_system)
self.a_equals_b_plus_2_constraint = self.create_a_equals_b_plus_2_constraint(
)
self.a_equals_c_minus_1_constraint = self.create_a_equals_c_minus_1_constraint(
)
self.a_plus_b_equals_c_constraint = self.create_a_plus_b_equals_c_constraint(
)
def create_a_equals_b_plus_2_constraint(self):
mA = Method([self.a], [self.b], lambda a: a - 2)
mB = Method([self.b], [self.a], lambda b: b + 2)
return Constraint(lambda a, b: a == b + 2, Strength.STRONG,
[self.a, self.b], [mA, mB])
def create_a_equals_c_minus_1_constraint(self):
mA = Method([self.a], [self.c], lambda a: c - 1)
mC = Method([self.c], [self.a], lambda c: a + 1)
return Constraint(lambda a, c: a == c - 1, Strength.STRONG,
[self.a, self.c], [mA, mC])
def create_a_plus_b_equals_c_constraint(self):
mC = Method([self.a, self.b], [self.c], lambda a, b: a + b)
mB = Method([self.a, self.c], [self.b], lambda a, c: c - a)
mA = Method([self.b, self.c], [self.a], lambda b, c: c - b)
return Constraint(lambda a, b, c: a + b == c, Strength.STRONG,
[self.a, self.b, self.c], [mA, mB, mC])
def simple_constraint_system(self):
self.constraint_system.add_constraint(self.a_equals_b_plus_2_contraint)
self.constraint_system.add_constraint(
self.a_equals_c_minus_1_contraint)
return self.constraint_system
class PplanTests(TestCase):
def setUp(self):
self.constraint_system = ConstraintSystem()
def test_pplan_add_for_one_constraint(self):
v = Variable("v", 1, self.constraint_system)
constraint = Constraint(lambda x: x == 5, Strength.STRONG, v,
Method([], v, lambda: 5))
self.constraint_system.add_constraint(constraint)
self.assertTrue(constraint, v.determined_by)
self.assertEqual(
constraint.add_to_pplan([],
self.constraint_system.marker.new_mark()),
[constraint], "should contain only the constraint")
def test_pplan_add_for_two_constraint(self):
v = Variable("v", 1, self.constraint_system)
constraint1 = Constraint(lambda x: x == 5, Strength.WEAK, v,
Method([], v, lambda: 5))
constraint2 = Constraint(lambda x: x == 6, Strength.STRONG, v,
Method([], v, lambda: 6))
self.constraint_system.add_constraint(constraint1)
self.constraint_system.add_constraint(constraint2)
self.assertFalse(constraint1.is_enforced())
self.assertTrue(constraint2.is_enforced())
self.assertTrue(constraint2, v.determined_by)
self.assertEqual(
constraint2.add_to_pplan([],
self.constraint_system.marker.new_mark()),
[constraint2], "does not add other constraint of \
a variable if it is not enforced")
self.assertEqual(
constraint1.add_to_pplan([],
self.constraint_system.marker.new_mark()),
[], "does not add unenforced constraints")
def test_pplan_add_for_variable(self):
v = Variable("v", 1, self.constraint_system)
self.assertEqual(
v.add_to_pplan([], self.constraint_system.marker.new_mark()), [],
"plain variable return pplan as it was")
class CycleTest(TestCase):
def setUp(self):
self.cs = ConstraintSystem()
def test_cycle_should_be_detected(self):
a, b, c, d = self.cs.create_variables(["a", "b", "c", "d"], [1, 2, 3, 0])
one = Variable("1", 1, self.cs)
cn1 = ConstraintFactory().scale_constraint(b, a, one, one, Strength.STRONG)
cn2 = ConstraintFactory().scale_constraint(c, b, one, one, Strength.STRONG)
cn3 = ConstraintFactory().scale_constraint(a, c, one, one, Strength.STRONG)
cn4 = ConstraintFactory().scale_constraint(a, d, one, one, Strength.STRONG)
with self.assertRaises(CycleException) as e:
for cn in [cn1, cn2, cn3, cn4]:
self.cs.add_constraint(cn)
def test_cycle_variables_should_be_invalid(self):
a, b, c, d = self.cs.create_variables(["a", "b", "c", "d"], [1, 2, 3, 0])
one = Variable("1", 1, self.cs)
cn1 = ConstraintFactory().scale_constraint(b, a, one, one, Strength.STRONG, "cn1")
cn2 = ConstraintFactory().scale_constraint(c, b, one, one, Strength.STRONG, "cn2")
cn3 = ConstraintFactory().scale_constraint(a, c, one, one, Strength.STRONG, "cn3")
cn4 = ConstraintFactory().scale_constraint(a, d, one, one, Strength.STRONG, "cn4")
try:
for cn in [cn1, cn2, cn3, cn4]:
self.cs.add_constraint(cn)
except CycleException as c_exc:
self.assertEqual(set([cn1, cn2, cn3]), c_exc.cycled_constraints)
for var in c_exc.cycled_variables:
self.assertFalse(var.valid, "%s should be invalid" %(var) )
else:
raise Exception("should have risen an CycleException")
def test_should_not_detect_a_cycle(self):
a, b, c = self.cs.create_variables(["a", "b", "c"], [1, 2, 3])
m1 = Method([a, c], [b], lambda a,c: a + c)
m2 = Method([b, c], [a], lambda b,c: b - c)
cn = Constraint(lambda a,b,c: a + c == b, Strength.STRONG, [a, b, c], [m1, m2], "cn1")
self.cs.add_constraint(cn)
a.stay()
b.set_value(4)
c.set_value(8)
def __init__(self):
self.constraint_system = ConstraintSystem()
self.a = Variable("a", 1, self.constraint_system)
self.b = Variable("b", 2, self.constraint_system)
self.c = Variable("c", 3, self.constraint_system)
self.a_equals_b_plus_2_constraint = self.create_a_equals_b_plus_2_constraint()
self.a_equals_c_minus_1_constraint = self.create_a_equals_c_minus_1_constraint()
self.a_plus_b_equals_c_constraint = self.create_a_plus_b_equals_c_constraint()
class PplanTests(TestCase):
def setUp(self):
self.constraint_system = ConstraintSystem()
def test_pplan_add_for_one_constraint(self):
v = Variable("v", 1, self.constraint_system)
constraint = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.constraint_system.add_constraint(constraint)
self.assertTrue(constraint, v.determined_by)
self.assertEqual(
constraint.add_to_pplan([], self.constraint_system.marker.new_mark()),
[constraint],
"should contain only the constraint")
def test_pplan_add_for_two_constraint(self):
v = Variable("v", 1, self.constraint_system)
constraint1 = Constraint(lambda x: x == 5, Strength.WEAK, v, Method([], v, lambda: 5))
constraint2 = Constraint(lambda x: x == 6, Strength.STRONG, v, Method([], v, lambda: 6))
self.constraint_system.add_constraint(constraint1)
self.constraint_system.add_constraint(constraint2)
self.assertFalse(constraint1.is_enforced())
self.assertTrue(constraint2.is_enforced())
self.assertTrue(constraint2, v.determined_by)
self.assertEqual(
constraint2.add_to_pplan([], self.constraint_system.marker.new_mark()),
[constraint2],
"does not add other constraint of \
a variable if it is not enforced")
self.assertEqual(
constraint1.add_to_pplan([], self.constraint_system.marker.new_mark()),
[],
"does not add unenforced constraints")
def test_pplan_add_for_variable(self):
v = Variable("v", 1, self.constraint_system)
self.assertEqual(
v.add_to_pplan([], self.constraint_system.marker.new_mark()),
[],
"plain variable return pplan as it was")
def setUp(self):
self.cs = ConstraintSystem()
self.vars = self.cs.create_variables(["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.vars
m1_2 = Method(self.v1, self.v2, lambda x: x // 2)
m1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.cn = Constraint(lambda v1, v2, v3: True, Strength.STRONG, self.vars, [m1_3, m1_2])
self.cs.add_constraint(self.cn)
def setUp(self):
self.constraint_system = ConstraintSystem()
self.variables = self.constraint_system.create_variables(["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.variables
method1_2 = Method(self.v1, self.v2, lambda x: x // 2)
method1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.constraint = Constraint(lambda v1, v2, v3: True, Strength.STRONG, self.variables, [method1_3, method1_2])
self.constraint_system.add_constraint(self.constraint)
def test_adding_iterative_should_be_in_the_right_order(self):
cs = ConstraintSystem()
all_vars = cs.create_variables(["a", "b", "c"], [1, 2, 3])
a, b, c = all_vars
m1 = Method([a, c], [b], lambda a,c: a + c)
m2 = Method([b, c], [a], lambda b,c: b - c)
cn = Constraint(lambda a,b,c: a + c == b, Strength.STRONG, [a, b, c], [m1, m2], "cn1")
self.cs.add_constraint(cn)
a.stay()
a_stay_cn = a.stay_constraint
c.set_value(8)
c_set_cn = cs.forced_constraint
cs.exec_roots = [c_set_cn, a_stay_cn]
self.assertEqual([cn, c_set_cn, a_stay_cn], cs.exec_pplan_create())
class ConstraintFactoryTestClass(unittest.TestCase):
__name__ = "ConstraintFactoryTestClass"
def setUp(self):
self.constraint_system = ConstraintSystem()
def test_equality_constraint(self):
variable1 = Variable("variable1", 10, self.constraint_system)
variable2 = Variable("variable2", 20, self.constraint_system)
constraint = ConstraintFactory.equality_constraint(
variable1,
variable2,
Strength.STRONG
)
self.constraint_system.add_constraint(constraint)
self.assertTrue(variable1.get_value()==variable2.get_value())
def test_scale_constraint(self):
destination = Variable("destination", 1, self.constraint_system)
source = Variable("source", 2, self.constraint_system)
scale = Variable("scale", 3, self.constraint_system)
offset = Variable("offset", 4, self.constraint_system)
constraint = ConstraintFactory.scale_constraint(
destination,
source,
scale,
offset,
Strength.STRONG
)
self.constraint_system.add_constraint(constraint)
self.assertTrue(destination.get_value() == scale.get_value() * source.get_value() + offset.get_value())
destination.set_value(100)
self.assertTrue(destination.get_value() == scale.get_value() * source.get_value() + offset.get_value())
class UpdateMethodGraphTests(TestCase):
def setUp(self):
self.build_mvine = Mvine.build
Mvine.build = Mock(return_value = True)
self.cs = ConstraintSystem()
self.cs.propagate_walk_strength = Mock(return_value = True)
self.cs.collect_unenforced = Mock(return_value = True)
self.f = Fixture()
def tearDown(self):
Mvine.build = self.build_mvine
def test_update_method_graph_with_no_constraints(self):
self.cs.update_method_graph()
self.assertEqual([], self.cs.exec_roots)
def test_update_method_graph_with_a_constraint(self):
self.cs.build_mvine = Mock(return_value = True)
c = self.f.a_equals_b_plus_2_constraint
self.cs.unenforced_constraints.add(c)
self.cs.update_method_graph()
self.assertEqual([c], self.cs.exec_roots)
class UpdateMethodGraphTests(TestCase):
def setUp(self):
self.build_mvine = Mvine.build
Mvine.build = Mock(return_value = True)
self.cs = ConstraintSystem()
self.cs._propagate_walk_strength = Mock(return_value = True)
self.cs.collect_unenforced = Mock(return_value = True)
self.f = Fixture()
def tearDown(self):
Mvine.build = self.build_mvine
def test_update_method_graph_with_no_constraints(self):
self.cs._update_method_graph()
self.assertEqual([], self.cs.exec_roots)
def test_update_method_graph_with_a_constraint(self):
self.cs.build_mvine = Mock(return_value = True)
c = self.f.a_equals_b_plus_2_constraint
self.cs.unenforced_constraints.add(c)
self.cs._update_method_graph()
self.assertEqual([c], self.cs.exec_roots)
class ConstraintFactoryTestClass(unittest.TestCase):
__name__ = "ConstraintFactoryTestClass"
def setUp(self):
self.constraint_system = ConstraintSystem()
def test_equality_constraint(self):
variable1 = Variable("variable1", 10, self.constraint_system)
variable2 = Variable("variable2", 20, self.constraint_system)
constraint = ConstraintFactory.equality_constraint(
variable1, variable2, Strength.STRONG)
self.constraint_system.add_constraint(constraint)
self.assertTrue(variable1.get_value() == variable2.get_value())
def test_scale_constraint(self):
destination = Variable("destination", 1, self.constraint_system)
source = Variable("source", 2, self.constraint_system)
scale = Variable("scale", 3, self.constraint_system)
offset = Variable("offset", 4, self.constraint_system)
constraint = ConstraintFactory.scale_constraint(
destination, source, scale, offset, Strength.STRONG)
self.constraint_system.add_constraint(constraint)
self.assertTrue(
destination.get_value() == scale.get_value() * source.get_value() +
offset.get_value())
destination.set_value(100)
self.assertTrue(
destination.get_value() == scale.get_value() * source.get_value() +
offset.get_value())
def setUp(self):
cs = ConstraintSystem()
self.first = None
self.last = None
prev = None
n = 50
# We need to go up to n inclusively, as this is done
# in the original test as well
for i in range(n + 1):
name = "v%s" % i
v = Variable(name, 0, cs)
if prev is not None:
c = ConstraintFactory.equality_constraint(prev, v, Strength.STRONG)
cs.add_constraint(c)
if i == 0:
self.first = v
if i == n:
self.last = v
prev = v
self.last.stay()
class MVineTests(TestCase):
def setUp(self):
self.marker = marker
self.mvine = Mvine(self.marker)
self.constraint_system = ConstraintSystem()
def test_build_mvine(self):
v1, v2, v3 = self.constraint_system.create_variables(["v1", "v2", "v3"], [3, 4, 5])
method1 = Method(
[v1, v2],
[v3],
lambda v1, v2: (v1 + v2) / 2)
method2 = Method(
[v3, v2],
[v1],
lambda v3, v2: 2 * v3 - v2)
method3 = Method([v3, v1], [v2], lambda v3, v1: 2 * v3 - v1)
cn = Constraint(
lambda v1, v2, v3: True,
Strength.STRONG,
[v1, v2, v3],
[method1, method2, method3])
self.assertIsNone(v1.determined_by)
self.assertIsNone(v2.determined_by)
self.assertIsNone(v3.determined_by)
self.assertEqual(3, v1.get_value())
self.assertEqual(4, v2.get_value())
self.assertEqual(5, v3.get_value())
redetermined_varariables = set()
self.assertTrue(self.mvine.build(cn, redetermined_varariables))
self.assertEqual(set([v3]), redetermined_varariables)
self.assertIsNone(v1.determined_by)
self.assertIsNone(v2.determined_by)
self.assertEqual(cn, v3.determined_by)
self.assertIsNotNone(cn.mark)
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30), self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0), self.constraint_system)
mMp = Method([self.point1, self.point2], [self.midpoint],
lambda p1, p2: Point((p1.X + p2.X) / 2 , (p1.Y + p2.Y) / 2))
mP1 = Method([self.midpoint, self.point2], [self.point1],
lambda mp, p2: Point((2 * mp.X - p2.X) , (2 * mp.Y - p2.Y)))
mP2 = Method([self.midpoint, self.point1], [self.point2],
lambda mp, p1: Point((2 * mp.X - p1.X) , (2 * mp.Y - p1.Y)))
constraint = Constraint(
lambda point1, point2, midpoint: midpoint.is_midpoint(point1, point2),
Strength.STRONG,
[self.point1, self.point2, self.midpoint],
[mMp, mP1, mP2])
self.constraint_system.add_constraint(constraint)
class ConstraintSystemTest(unittest.TestCase):
"""
This only tests basic getters and setters, no constraint solving technology.
"""
def setUp(self):
self.cs = ConstraintSystem()
self.v1 = Variable("v1", 15, self.cs)
self.c1 = Constraint(lambda x: True, Strength.REQUIRED, [self.v1], [])
def test_create_variable(self):
self.assertTrue(self.v1 in self.cs.variables)
def test_variable_constraints_is_set_after_add_constraint(self):
self.cs.add_constraint(self.c1)
self.assertTrue(self.c1 in self.v1.constraints)
def test_variable_constraints_is_set_after_remove_constraint(self):
self.cs.add_constraint(self.c1)
self.cs.remove_constraint(self.c1)
self.assertEqual(set(), self.v1.constraints)
class ConstraintSystemTest(unittest.TestCase):
"""
This only tests basic getters and setters, no constraint solving technology.
"""
def setUp(self):
self.cs = ConstraintSystem()
self.v1 = Variable("v1", 15, self.cs)
self.c1 = Constraint(lambda x: True, Strength.REQUIRED, [self.v1], [])
def test_create_variable(self):
self.assertTrue(self.v1 in self.cs.variables)
def test_variable_constraints_is_set_after_add_constraint(self):
self.cs.add_constraint(self.c1)
self.assertTrue(self.c1 in self.v1.constraints)
def test_variable_constraints_is_set_after_remove_constraint(self):
self.cs.add_constraint(self.c1)
self.cs.remove_constraint(self.c1)
self.assertEqual(set(), self.v1.constraints)
class MidpointTest(unittest.TestCase):
__name__ = "MidpointTest"
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30),
self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0),
self.constraint_system)
mMp = Method([self.point1, self.point2], [self.midpoint],
lambda p1, p2: Point((p1.X + p2.X) / 2,
(p1.Y + p2.Y) / 2))
mP1 = Method([self.midpoint, self.point2], [self.point1],
lambda mp, p2: Point((2 * mp.X - p2.X),
(2 * mp.Y - p2.Y)))
mP2 = Method([self.midpoint, self.point1], [self.point2],
lambda mp, p1: Point((2 * mp.X - p1.X),
(2 * mp.Y - p1.Y)))
constraint = Constraint(
lambda point1, point2, midpoint: midpoint.is_midpoint(
point1, point2), Strength.STRONG,
[self.point1, self.point2, self.midpoint], [mMp, mP1, mP2])
self.constraint_system.add_constraint(constraint)
def test_contraint(self):
midpoint = self.midpoint.get_value()
point1 = self.point1.get_value()
point2 = self.point2.get_value()
self.assertTrue(midpoint.is_midpoint(point1, point2))
def test_change_point1(self):
self.point1.set_value(Point(0, 0))
point1 = self.point1.get_value()
self.test_contraint()
self.assertEqual(point1.X, 0)
self.assertEqual(point1.Y, 0)
def test_change_midpoint(self):
self.midpoint.set_value(Point(0, 0))
midpoint = self.midpoint.get_value()
self.test_contraint()
self.assertEqual(midpoint.X, 0)
self.assertEqual(midpoint.Y, 0)
def test_change_several_points(self):
self.midpoint.set_value(Point(0, 0))
self.point1.set_value(Point(10, 10))
self.point2.set_value(Point(50, 50))
point2 = self.point2.get_value()
self.test_contraint()
self.assertEqual(point2.X, 50)
self.assertEqual(point2.Y, 50)
def test_change_two_points_at_the_same_time(self):
self.constraint_system.change_variable_values(
[self.point1, self.point2],
[Point(0, 0), Point(20, 20)])
point1 = self.point1.get_value()
point2 = self.point2.get_value()
self.test_contraint()
self.assertEqual(point1.X, 0)
self.assertEqual(point1.Y, 0)
self.assertEqual(point2.X, 20)
self.assertEqual(point2.Y, 20)
class MidpointTest(unittest.TestCase):
__name__ = "MidpointTest"
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30), self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0), self.constraint_system)
mMp = Method([self.point1, self.point2], [self.midpoint],
lambda p1, p2: Point((p1.X + p2.X) / 2 , (p1.Y + p2.Y) / 2))
mP1 = Method([self.midpoint, self.point2], [self.point1],
lambda mp, p2: Point((2 * mp.X - p2.X) , (2 * mp.Y - p2.Y)))
mP2 = Method([self.midpoint, self.point1], [self.point2],
lambda mp, p1: Point((2 * mp.X - p1.X) , (2 * mp.Y - p1.Y)))
constraint = Constraint(
lambda point1, point2, midpoint: midpoint.is_midpoint(point1, point2),
Strength.STRONG,
[self.point1, self.point2, self.midpoint],
[mMp, mP1, mP2])
self.constraint_system.add_constraint(constraint)
def test_contraint(self):
midpoint = self.midpoint.get_value()
point1 = self.point1.get_value()
point2 = self.point2.get_value()
self.assertTrue(midpoint.is_midpoint(point1,point2))
def test_change_point1(self):
self.point1.set_value(Point(0, 0))
point1 = self.point1.get_value()
self.test_contraint()
self.assertEqual(point1.X, 0)
self.assertEqual(point1.Y, 0)
def test_change_midpoint(self):
self.midpoint.set_value(Point(0, 0))
midpoint = self.midpoint.get_value()
self.test_contraint()
self.assertEqual(midpoint.X, 0)
self.assertEqual(midpoint.Y, 0)
def test_change_several_points(self):
self.midpoint.set_value(Point(0, 0))
self.point1.set_value(Point(10, 10))
self.point2.set_value(Point(50, 50))
point2 = self.point2.get_value()
self.test_contraint()
self.assertEqual(point2.X, 50)
self.assertEqual(point2.Y, 50)
def test_change_two_points_at_the_same_time(self):
self.constraint_system.change_variable_values(
[self.point1, self.point2],
[Point(0, 0), Point(20, 20)]
)
point1 = self.point1.get_value()
point2 = self.point2.get_value()
self.test_contraint()
self.assertEqual(point1.X, 0)
self.assertEqual(point1.Y, 0)
self.assertEqual(point2.X, 20)
self.assertEqual(point2.Y, 20)
class ExecFromRootTests(TestCase):
def setUp(self):
self.cs = ConstraintSystem()
def test_exec_pplan_create_with_empty_input(self):
pplan = self.cs.exec_pplan_create()
self.assertEqual([], pplan)
def test_exec_pplan_create_with_one_cn(self):
v = Variable("v", 1, self.cs)
cn = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.cs.add_constraint(cn)
self.cs.exec_roots = [cn]
self.assertEqual([cn], self.cs.exec_pplan_create())
def test_exec_pplan_create_with_one_unmarked_cn(self):
v = Variable("v", 1, self.cs)
cn = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.cs.add_constraint(cn)
self.cs.exec_roots = [cn]
self.assertEqual([cn], self.cs.exec_pplan_create())
def test_exec_pplan_create_with_one_marked_cn(self):
v = Variable("v", 1, self.cs)
cn = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.cs.add_constraint(cn)
cn.mark = self.cs.mark
self.cs.exec_roots = [cn]
self.assertEqual([], self.cs.exec_pplan_create())
@skip("Broken test.")
def test_exec_pplan_create_with_one_undetermined_var(self):
v = Variable("v", 1, self.cs)
cn = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.cs.add_constraint(cn)
v.determined_by = None
self.cs.exec_roots = [v]
self.assertEqual([cn], self.cs.exec_pplan_create())
def test_exec_pplan_create_with_one_determined_var(self):
v = Variable("v", 1, self.cs)
cn = Constraint(lambda x: x == 5, Strength.STRONG, v, Method([], v, lambda: 5))
self.cs.add_constraint(cn)
self.cs.exec_roots = [v]
self.assertEqual([], self.cs.exec_pplan_create())
class ExtendedMidpointTest(unittest.TestCase):
__name__ = "ExtendedMidpointTest"
def setUp(self):
self.constraint_system = ConstraintSystem()
self.point1 = Variable("Point 1", Point(4, 10), self.constraint_system)
self.point2 = Variable("Point 2", Point(10, 30), self.constraint_system)
self.point3 = Variable("Point 3", Point(50, 20), self.constraint_system)
self.point4 = Variable("Point 4", Point(100, 30), self.constraint_system)
self.midpoint = Variable("midpoint", Point(0, 0), self.constraint_system)
mpmp3p4 = Method([self.midpoint, self.point3, self.point4], [self.point1, self.point2],
lambda pm, p3, p4: (
Point(
pm.X - (p4.X - p3.X),
pm.Y - (p4.Y - p3.Y)
),
Point(
pm.X + (p4.X - p3.X),
pm.Y + (p4.Y - p3.Y)
)
)
)
mp1pmp3 = Method([self.point1, self.midpoint, self.point3], [self.point2, self.point4],
lambda p1, pm, p3: (
Point(
2 * pm.X - p1.X,
2 * pm.Y - p1.Y
),
Point(
p3.X + (pm.X - p1.X),
p3.Y + (pm.Y - p1.Y)
)
)
)
mpmp2p4 = Method([self.midpoint, self.point2, self.point4], [self.point1, self.point3],
lambda pm, p2, p4: (
Point(
2 * pm.X - p2.X,
2 * pm.Y - p2.Y
),
Point(
p4.X + (pm.X - p2.X),
p4.Y + (pm.Y - p2.Y)
)
)
)
constraint = Constraint(
lambda p1, p2, p3, p4, pm: pm.is_midpoint(p1, p2) and
p1.distance(pm) == p3.distance(p4),
Strength.STRONG,
[self.point1, self.point2, self.point3, self.point4, self.midpoint],
[mpmp3p4, mp1pmp3, mpmp2p4])
self.constraint_system.add_constraint(constraint)
self.point3.stay()
self.point4.stay()
def test_contraint(self):
pm = self.midpoint.get_value()
p1 = self.point1.get_value()
p2 = self.point2.get_value()
p3 = self.point3.get_value()
p4 = self.point4.get_value()
self.assertTrue(pm.is_midpoint(p1,p2))
self.assertTrue(p1.distance(pm) == p3.distance(p4))
def test_change_point1(self):
pm_old = self.midpoint.get_value()
self.point1.set_value(Point(0, 0))
self.test_contraint()
self.assertTrue(self.point1.get_value().equals(Point(0,0)))
self.assertTrue(self.midpoint.get_value().equals(pm_old))
def test_change_midpoint(self):
self.midpoint.set_value(Point(0, 0))
midpoint = self.midpoint.get_value()
self.test_contraint()
self.assertTrue(self.midpoint.get_value(), Point(0,0))
def test_change_point3(self):
pm_old = self.midpoint.get_value()
self.point3.set_value(Point(0, 0))
self.test_contraint()
self.assertTrue(self.point3.get_value().equals(Point(0,0)))
self.assertTrue(self.midpoint.get_value().equals(pm_old))
def setUp(self):
self.cs = ConstraintSystem()
self.v1 = Variable("v1", 15, self.cs)
self.c1 = Constraint(lambda x: True, Strength.REQUIRED, [self.v1], [])
from __future__ import division
import sys
sys.path.append("../src")
sys.path.append("../tests")
from skypyblue.core import ConstraintSystem
from skypyblue.models import Constraint, Strength, Variable, Method
cs = ConstraintSystem()
v1 = Variable("v1", 16, cs)
v2 = Variable("v2", 16, cs)
v3 = Variable("v3", 16, cs)
v4 = Variable("v4", 10, cs)
v4.stay()
# v1 + v2 = v3, v1 - v2 = v4
m12_34 = Method([v1, v2], [v3, v4], lambda v1, v2: (v1 + v2, v1 - v2))
m34_12 = Method([v3, v4], [v1, v2], lambda v3, v4: ((v3 + v4) / 2,
(v3 - v4) / 2))
cn1 = Constraint(lambda v1, v2, v3, v4: v1 + v2 == v3 and v1 - v2 == v4,
Strength.STRONG, [v1, v2, v3, v4], [m12_34, m34_12])
cs.add_constraint(cn1)
def print_values():
def setUp(self):
self.cs = ConstraintSystem()
self.v1 = Variable("v1", 15, self.cs)
self.c1 = Constraint(lambda x: True, Strength.REQUIRED, [self.v1], [])
def setUp(self): self.marker = marker self.mvine = Mvine(self.marker) self.cs = ConstraintSystem()
class ConstraintTests(TestCase):
def setUp(self):
self.cs = ConstraintSystem()
self.vars = self.cs.create_variables(["v1", "v2", "v3"], [4, 5, 3])
self.v1, self.v2, self.v3 = self.vars
m1_2 = Method(self.v1, self.v2, lambda x: x // 2)
m1_3 = Method(self.v1, self.v3, lambda x: x // 3)
self.cn = Constraint(lambda v1, v2, v3: True, Strength.STRONG, self.vars, [m1_3, m1_2])
self.cs.add_constraint(self.cn)
def tearDown(self):
pass
def test_adding_enforced_to_pplan(self):
self.assertIsNone(self.cn.mark)
mark = self.cs.marker.new_mark()
pplan = self.cn.add_to_pplan([], mark)
self.assertEqual([self.cn], pplan)
self.assertEqual(mark, self.cn.mark)
def test_adding_unenforced_to_pplan(self):
self.cn.selected_method = None
self.assertIsNone(self.cn.mark)
pplan = self.cn.add_to_pplan([], self.cs.marker.new_mark())
self.assertEqual([], pplan)
self.assertIsNone(self.cn.mark)
def test_adding_with_the_same_mark(self):
mark = self.cs.marker.new_mark()
self.cn.mark = mark
pplan = self.cn.add_to_pplan([], mark)
self.assertEqual([], pplan)
self.assertEqual(mark, self.cn.mark)
def test_adding_with_other_mark(self):
mark1 = self.cs.marker.new_mark()
mark2 = self.cs.marker.new_mark()
self.cn.mark = mark1
pplan = self.cn.add_to_pplan([], mark2)
self.assertEqual([self.cn], pplan)
self.assertEqual(mark2, self.cn.mark)
def test_adding_iterative_should_be_in_the_right_order(self):
cs = ConstraintSystem()
all_vars = cs.create_variables(["a", "b", "c"], [1, 2, 3])
a, b, c = all_vars
m1 = Method([a, c], [b], lambda a,c: a + c)
m2 = Method([b, c], [a], lambda b,c: b - c)
cn = Constraint(lambda a,b,c: a + c == b, Strength.STRONG, [a, b, c], [m1, m2], "cn1")
self.cs.add_constraint(cn)
a.stay()
a_stay_cn = a.stay_constraint
c.set_value(8)
c_set_cn = cs.forced_constraint
cs.exec_roots = [c_set_cn, a_stay_cn]
self.assertEqual([cn, c_set_cn, a_stay_cn], cs.exec_pplan_create())
class CycleTest(TestCase):
def setUp(self):
self.constraint_system = ConstraintSystem()
def test_cycle_should_be_detected(self):
a, b, c, d = self.constraint_system.create_variables(
["a", "b", "c", "d"], [1, 2, 3, 0])
one = Variable("1", 1, self.constraint_system)
constraint1 = ConstraintFactory().scale_constraint(
b, a, one, one, Strength.STRONG)
constraint2 = ConstraintFactory().scale_constraint(
c, b, one, one, Strength.STRONG)
constraint3 = ConstraintFactory().scale_constraint(
a, c, one, one, Strength.STRONG)
constraint4 = ConstraintFactory().scale_constraint(
a, d, one, one, Strength.STRONG)
with self.assertRaises(CycleException) as e:
for constraint in [
constraint1, constraint2, constraint3, constraint4
]:
self.constraint_system.add_constraint(constraint)
def test_cycle_variables_should_be_invalid(self):
a, b, c, d = self.constraint_system.create_variables(
["a", "b", "c", "d"], [1, 2, 3, 0])
one = Variable("1", 1, self.constraint_system)
constraint1 = ConstraintFactory().scale_constraint(
b, a, one, one, Strength.STRONG, "constraint1")
constraint2 = ConstraintFactory().scale_constraint(
c, b, one, one, Strength.STRONG, "constraint2")
constraint3 = ConstraintFactory().scale_constraint(
a, c, one, one, Strength.STRONG, "constraint3")
constraint4 = ConstraintFactory().scale_constraint(
a, d, one, one, Strength.STRONG, "constraint4")
try:
for constraint in [
constraint1, constraint2, constraint3, constraint4
]:
self.constraint_system.add_constraint(constraint)
except CycleException as c_exc:
self.assertEqual(set([constraint1, constraint2, constraint3]),
set(c_exc.cycled_constraints))
for variable in c_exc.cycled_variables:
self.assertFalse(variable.valid,
"%s should be invalid" % (variable))
else:
raise Exception("should have risen an CycleException")
def test_should_not_detect_a_cycle(self):
a, b, c = self.constraint_system.create_variables(["a", "b", "c"],
[1, 2, 3])
method1 = Method([a, c], [b], lambda a, c: a + c)
method2 = Method([b, c], [a], lambda b, c: b - c)
constraint = Constraint(lambda a, b, c: a + c == b, Strength.STRONG,
[a, b, c], [method1, method2], "constraint1")
self.constraint_system.add_constraint(constraint)
a.stay()
b.set_value(4)
c.set_value(8)
from __future__ import division
import sys
sys.path.append("../src")
sys.path.append("../tests")
from skypyblue.core import ConstraintSystem
from skypyblue.models import Constraint, Strength, Variable, Method
cs = ConstraintSystem()
v1 = Variable("v1", 16, cs)
v2 = Variable("v2", 16, cs)
v3 = Variable("v3", 16, cs)
v4 = Variable("v4", 10, cs)
v4.stay()
# v1 + v2 = v3, v1 - v2 = v4
m12_34 = Method([v1, v2], [v3, v4],
lambda v1, v2: (v1 + v2 , v1 - v2))
m34_12 = Method([v3, v4], [v1, v2],
lambda v3, v4: ((v3 + v4) / 2 , (v3 - v4) / 2))
cn1 = Constraint(
lambda v1, v2, v3, v4: v1 + v2 == v3 and v1 - v2 == v4,
Strength.STRONG,
[v1, v2, v3, v4],
[m12_34, m34_12])
def setUp(self): self.constraint_system = ConstraintSystem()
def setUp(self): self.marker = marker self.mvine = Mvine(self.marker) self.constraint_system = ConstraintSystem()
There are five points (Pm, P1, P2, P3, P4).
We want to implement the following behavior:
- Pm is the midpoint of P1 and P2.
- If we grab Pm, we move the whole line P1-Pm-P2.
- If we grab P1 or P2, we change the direction of the line.
- The direction of the line P1-Pm-P2 is the same as P3-P4.
"""
import pygame, math, sys
sys.path.append("../src")
sys.path.append("../tests")
from skypyblue.core import ConstraintSystem
from skypyblue.models import *
from point import Point
cs = ConstraintSystem()
pm_var = Variable("pm", Point(600, 400), cs)
p1_var = Variable("p1", Point(250, 100), cs)
p2_var = Variable("p2", Point(200, 400), cs)
p3_var = Variable("p3", Point(100, 150), cs)
p4_var = Variable("p4", Point(100, 250), cs)
def all_points():
return [p1_var, pm_var, p2_var, p3_var, p4_var]
def main_line():
return [p1_var, pm_var, p2_var]
def direction_line():
return [p3_var, p4_var]
def setUp(self): self.cs = ConstraintSystem()
def setUp(self):
self.constraint_system = ConstraintSystem()
