def testMidPoint(self):
p = cfg.Program()
x = p.NewVariable()
y = p.NewVariable()
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x1 = x.AddBinding("1", source_set=[], where=n1)
y1 = y.AddBinding("1", source_set=[x1], where=n1)
n2 = n1.ConnectNew("n2")
x2 = x.AddBinding("2", source_set=[], where=n2)
n3 = n2.ConnectNew("n3")
self.assertTrue(n3.HasCombination([y1, x2]))
self.assertTrue(n3.HasCombination([x2, y1]))
def testFilter1(self):
# x.ab = A()
# ,---+------------.
# | n3 |
# x = X() | x.ab = B() |
# +------------+---+------------+------------+
# n1 n2 n4 n5 n6
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
n3 = n2.ConnectNew("n3")
n4 = n2.ConnectNew("n4")
n5 = n3.ConnectNew("n5")
n4.ConnectTo(n5)
n6 = n5.ConnectNew("n6")
n5.ConnectTo(n6)
all_x = p.NewVariable()
x = all_x.AddBinding({}, source_set=[], where=n1)
ab = p.NewVariable()
x.data["ab"] = ab
a = ab.AddBinding("A", source_set=[], where=n3)
b = ab.AddBinding("B", source_set=[], where=n4)
p.entrypoint = n1
self.assertFalse(a.IsVisible(n1) or b.IsVisible(n1))
self.assertFalse(a.IsVisible(n2) or b.IsVisible(n2))
self.assertTrue(a.IsVisible(n3))
self.assertTrue(b.IsVisible(n4))
self.assertEquals(ab.Filter(n1), [])
self.assertEquals(ab.Filter(n2), [])
self.assertEquals(ab.FilteredData(n3), ["A"])
self.assertEquals(ab.FilteredData(n4), ["B"])
self.assertSameElements(["A", "B"], ab.FilteredData(n5))
self.assertSameElements(["A", "B"], ab.FilteredData(n6))
def testMergeOneVariable(self):
p = cfg.Program()
n0 = p.NewCFGNode("n0")
u = p.NewVariable([0], [], n0)
self.assertIs(p.MergeVariables(n0, [u]), u)
self.assertIs(p.MergeVariables(n0, [u, u]), u)
self.assertIs(p.MergeVariables(n0, [u, u, u]), u)
def testProgramFreeze(self):
p = cfg.Program()
n = p.NewCFGNode("n")
self._Freeze(p, entrypoint=n)
self.assertRaises(AssertionError, p.NewCFGNode)
self.assertRaises(AssertionError, p.NewCFGNode, "named")
self.assertRaises(AssertionError, p.NewCFGNode, name="named")
def testFindNodeBackwards(self):
# +-->n2--. +--->n6--.
# | c3 v | c3 v
# n1 n4 --> n5<---+ n8
# | ^c1 c2| | ^
# +-->n3--' +--->n7--'
p = cfg.Program()
n1 = p.NewCFGNode("n1")
c1 = p.NewVariable().AddBinding("1", source_set=[], where=n1)
c2 = p.NewVariable().AddBinding("2", source_set=[], where=n1)
c3 = p.NewVariable().AddBinding("3", source_set=[], where=n1)
n2 = n1.ConnectNew("n2", c3)
n3 = n1.ConnectNew("n3")
n4 = p.NewCFGNode("n4", c1)
n2.ConnectTo(n4)
n3.ConnectTo(n4)
n5 = n4.ConnectNew("n5", c2)
n6 = n5.ConnectNew("n6", c3)
n7 = n5.ConnectNew("n7")
n7.ConnectTo(n5)
n8 = p.NewCFGNode("n8")
n6.ConnectTo(n8)
n7.ConnectTo(n8)
f = p.CreateSolver()._path_finder
self.assertEqual((True, [n5, n4]), f.FindNodeBackwards(n8, n1, ()))
self.assertFalse(f.FindNodeBackwards(n8, n1, (n4, ))[0])
self.assertEqual((True, [n5]), f.FindNodeBackwards(n8, n5, ()))
self.assertEqual((True, [n5, n4]), f.FindNodeBackwards(n5, n4, ()))
self.assertEqual((True, [n5, n4, n2]), f.FindNodeBackwards(n5, n2, ()))
self.assertEqual((True, [n5, n4]), f.FindNodeBackwards(n5, n3, ()))
def testConditionsAreOrdered(self):
# The error case in this test is non-deterministic. The test tries to verify
# that the list returned by _PathFinder.FindNodeBackwards is ordered from
# child to parent.
# The error case would be a random order or the reverse order.
# To guarantee that this test is working go to FindNodeBackwards and reverse
# the order of self._on_path before generating the returned list.
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x1 = p.NewVariable().AddBinding("1", source_set=[], where=n1)
n2 = n1.ConnectNew("n2",
condition=p.NewVariable().AddBinding("1",
source_set=[],
where=n1))
n3 = n2.ConnectNew("n3",
condition=p.NewVariable().AddBinding("1",
source_set=[],
where=n2))
n4 = n3.ConnectNew("n3",
condition=p.NewVariable().AddBinding("1",
source_set=[],
where=n3))
# Strictly speaking n1, n2 and n3 would be enough to expose errors. n4 is
# added to increase the chance of a failure if the order is random.
self.assertTrue(n4.HasCombination([x1]))
def setUp(self):
# n1------->n2
# | |
# v v
# n3------->n4
# [n2] x = a; y = a
# [n3] x = b; y = b
# [n4] z = x & y
self.p = typegraph.Program()
self.n1 = self.p.NewCFGNode("n1")
self.n2 = self.n1.ConnectNew("n2")
self.n3 = self.n1.ConnectNew("n3")
self.n4 = self.n2.ConnectNew("n4")
self.n3.ConnectTo(self.n4)
self.x = self.p.NewVariable("x")
self.y = self.p.NewVariable("y")
self.z = self.p.NewVariable("z")
self.w = self.p.NewVariable("w")
self.xa = self.x.AddValue("a", source_set=[], where=self.n2)
self.ya = self.y.AddValue("a", source_set=[], where=self.n2)
self.xb = self.x.AddValue("b", source_set=[], where=self.n3)
self.yb = self.y.AddValue("b", source_set=[], where=self.n3)
self.za = self.z.AddValue("a", source_set=[self.xa, self.ya], where=self.n4)
self.zb = self.z.AddValue("b", source_set=[self.xb, self.yb], where=self.n4)
self.zab = self.z.AddValue("a&b")
self.zab.AddOrigin(source_set=[self.xa, self.yb], where=self.n4)
self.zab.AddOrigin(source_set=[self.xb, self.ya], where=self.n4)
self.p.entrypoint = self.n1
self.p.Freeze()
def testVariableSet(self):
p = cfg.Program()
node1 = p.NewCFGNode()
node2 = node1.ConnectNew()
d = p.NewVariable("d")
d.AddValue("v1", source_set=[], where=node1)
d.AddValue("v2", source_set=[], where=node2)
self.assertEquals(len(d.values), 2)
def testBindingPrettyPrint(self):
p = cfg.Program()
node = p.NewCFGNode()
u = p.NewVariable()
v1 = u.AddBinding(1, source_set=[], where=node)
v2 = u.AddBinding(2, source_set=[v1], where=node)
v3 = u.AddBinding(3, source_set=[v2], where=node)
v3.PrettyPrint() # smoke test
def testPasteBinding(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x = p.NewVariable()
ax = x.AddBinding("a", source_set=[], where=n1)
y = p.NewVariable()
y.PasteBinding(ax)
self.assertEqual(x.data, y.data)
def testVariableSet(self):
p = cfg.Program()
node1 = p.NewCFGNode("n1")
node2 = node1.ConnectNew("n2")
d = p.NewVariable()
d.AddBinding("v1", source_set=[], where=node1)
d.AddBinding("v2", source_set=[], where=node2)
self.assertEquals(len(d.bindings), 2)
def testEntryPoint(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
x = p.NewVariable("x")
a = x.AddBinding("a", source_set=[], where=n1)
a = x.AddBinding("b", source_set=[], where=n2)
self._Freeze(p, entrypoint=n1)
self.assertTrue(n2.HasCombination([a]))
def testNewVariable(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = p.NewCFGNode("n2")
x, y, z = "x", "y", "z"
variable = p.NewVariable(bindings=[x, y], source_set=[], where=n1)
variable.AddBinding(z, source_set=variable.bindings, where=n2)
self.assertSameElements([x, y, z], [v.data for v in variable.bindings])
self.assertTrue(any(len(e.origins) for e in variable.bindings))
def testNewVariable(self):
p = cfg.Program()
n1 = p.NewCFGNode()
n2 = p.NewCFGNode()
x, y, z = "x", "y", "z"
variable = p.NewVariable("xyz", values=[x, y], source_set=[], where=n1)
variable.AddValue(z, source_set=variable.values, where=n2)
self.assertSameElements([x, y, z], [v.data for v in variable.values])
self.assertTrue(any(len(e.origins) for e in variable.values))
def testNonFrozenSolving(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
x = p.NewVariable()
a = x.AddBinding("a", source_set=[], where=n1)
a = x.AddBinding("b", source_set=[], where=n2)
p.entrypoint = n1
self.assertTrue(n2.HasCombination([a]))
def testValueValue(self):
p = cfg.Program()
node = p.NewCFGNode()
u = p.NewVariable("v")
v1 = u.AddValue(None, source_set=[], where=node)
v2 = u.AddValue(u"data", source_set=[], where=node)
v3 = u.AddValue({1: 2}, source_set=[], where=node)
self.assertEquals(v1.data, None)
self.assertEquals(v2.data, u"data")
self.assertEquals(v3.data, {1: 2})
def testConditionOnStartNode(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
n3 = p.NewCFGNode("n3")
a = p.NewVariable().AddBinding("a", source_set=[], where=n3)
b = p.NewVariable().AddBinding("b", source_set=[], where=n1)
n2.condition = a
self.assertFalse(n2.HasCombination([b]))
self.assertTrue(n1.HasCombination([b]))
def testUnsatisfiableCondition(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x = p.NewVariable()
x1 = x.AddBinding("1", source_set=[], where=n1)
n2 = n1.ConnectNew("n2")
x2 = x.AddBinding("2", source_set=[], where=n2)
n3 = n2.ConnectNew("n3", condition=x2)
n4 = n3.ConnectNew("n4")
self.assertFalse(n4.HasCombination([x1]))
def testFilter2(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = p.NewCFGNode("n2")
n1.ConnectTo(n2)
x = p.NewVariable("x")
a = x.AddValue("a", source_set=[], where=n2)
self._Freeze(p, entrypoint=n1)
self.assertEquals(x.Filter(n1), [])
self.assertEquals(x.Filter(n2), [a])
def testAsciiTree(self):
p = cfg.Program()
node1 = p.NewCFGNode("n1")
node2 = node1.ConnectNew("n2")
node3 = node2.ConnectNew("n3")
_ = node3.ConnectNew()
# Just check sanity. Actual verification of the drawing algorithm is
# done in utils_test.py.
self.assertIsInstance(node1.AsciiTree(), str)
self.assertIsInstance(node1.AsciiTree(forward=True), str)
def testMergeBindings(self):
p = cfg.Program()
n0 = p.NewCFGNode("n0")
u = p.NewVariable()
u1 = u.AddBinding("1", source_set=[], where=n0)
v2 = u.AddBinding("2", source_set=[], where=n0)
w1 = p.MergeBindings(None, [u1, v2])
w2 = p.MergeBindings(n0, [u1, v2])
self.assertItemsEqual(w1.data, ["1", "2"])
self.assertItemsEqual(w2.data, ["1", "2"])
def testFilter2(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = p.NewCFGNode("n2")
n1.ConnectTo(n2)
x = p.NewVariable()
a = x.AddBinding("a", source_set=[], where=n2)
p.entrypoint = n1
self.assertEquals(x.Filter(n1), [])
self.assertEquals(x.Filter(n2), [a])
def testLoop(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
n2.ConnectTo(n1)
x = p.NewVariable()
a = x.AddBinding("a")
b = x.AddBinding("b")
a.AddOrigin(n1, [b])
b.AddOrigin(n2, [a])
self.assertTrue(n2.HasCombination([b]))
def testHiddenConflict2(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
x = p.NewVariable()
y = p.NewVariable()
x_a = x.AddBinding("a", source_set=[], where=n1)
x_b = x.AddBinding("b", source_set=[], where=n1)
y_b = y.AddBinding("b", source_set=[x_b], where=n1)
p.entrypoint = n1
self.assertFalse(n2.HasCombination([y_b, x_a]))
def testAssignToNewNoNode(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x = p.NewVariable()
ax = x.AddBinding("a", source_set=[], where=n1)
y = ax.AssignToNewVariable()
z = x.AssignToNewVariable()
ox, = x.bindings[0].origins
oy, = y.bindings[0].origins
oz, = z.bindings[0].origins
self.assertEqual(ox, oy, oz)
def testBindingBinding(self):
p = cfg.Program()
node = p.NewCFGNode()
u = p.NewVariable("v")
v1 = u.AddBinding(None, source_set=[], where=node)
v2 = u.AddBinding(u"data", source_set=[], where=node)
v3 = u.AddBinding({1: 2}, source_set=[], where=node)
self.assertEquals(v1.data, None)
self.assertEquals(v2.data, u"data")
self.assertEquals(v3.data, {1: 2})
self.assertEquals("$0=#%d" % id(v3.data), str(v3))
def testConflictingBindingsFromCondition(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = n1.ConnectNew("n2")
n3 = n2.ConnectNew("n3")
x = p.NewVariable()
x_a = x.AddBinding("a", source_set=[], where=n1)
x_b = x.AddBinding("b", source_set=[], where=n1)
p.entrypoint = n1
n2.condition = x_a
self.assertFalse(n3.HasCombination([x_b]))
def testConflicting(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
x = p.NewVariable()
a = x.AddBinding("a", source_set=[], where=n1)
b = x.AddBinding("b", source_set=[], where=n1)
p.entrypoint = n1
# At n1, x can either be a or b, but not both.
self.assertTrue(n1.HasCombination([a]))
self.assertTrue(n1.HasCombination([b]))
self.assertFalse(n1.HasCombination([a, b]))
def testId(self):
p = cfg.Program()
n1 = p.NewCFGNode("n1")
n2 = p.NewCFGNode("n2")
x = p.NewVariable()
y = p.NewVariable()
self.assertIsInstance(x.id, int)
self.assertIsInstance(y.id, int)
self.assertLess(x.id, y.id)
self.assertIsInstance(n1.id, int)
self.assertIsInstance(n2.id, int)
self.assertLess(n1.id, n2.id)
def testNodeBindings(self):
p = cfg.Program()
n1 = p.NewCFGNode("node1")
n2 = n1.ConnectNew("node2")
self.assertEquals(n1.name, "node1")
self.assertEquals(n2.name, "node2")
u = p.NewVariable()
a1 = u.AddBinding(1, source_set=[], where=n1)
a2 = u.AddBinding(2, source_set=[], where=n1)
a3 = u.AddBinding(3, source_set=[], where=n1)
a4 = u.AddBinding(4, source_set=[], where=n1)
self.assertSameElements([a1, a2, a3, a4], n1.bindings)
