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()
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 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.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()