def ID3(X, Y, attrs, currentDepth, maxDepth=7):
currentDepth += 1
# If all examples are positive, Return the single-node tree Root, with label = +.
# If all examples are negative, Return the single-node tree Root, with label = -.
if len(set(Y)) == 1:
return Leaf(Y[0])
# If the number of predicting attributes is empty, then return a single node tree with
# Label = most common value of the target attribute in the examples
if len(attrs) == 0 or currentDepth == maxDepth:
return Leaf(majorityElement(Y))
# A = The Attribute that best classifies examples.
A = findBestFeatureIndex(X, Y, attrs)
newAttrs = [attr for attr in attrs if attr != A]
# Decision Tree attribute for Root = A.
root = Node(A)
# For each possible value, vi, of A
for possible_value in [0, 1]:
# Let Examples(vi) be the subset of examples that have the value vi for A
X_s, Y_s = splitData(X, Y, A, possible_value)
if len(X_s) == 0 or len(Y_s) == 0:
# Then below this new branch add a leaf node with label = most common target value in the examples
root.addChild(possible_value, Leaf(majorityElement(Y)))
else:
# Else below this node add a subtree ID3(Examples_vi, TargetAttr, Attrs - {A})
root.addChild(possible_value, ID3(X_s, Y_s, newAttrs, currentDepth, maxDepth))
return root
def wf_ICALL(node, type, scope):
newNode = Node("ICALL")
newNode.addAttribute(node.attributes[0])
item = lookup(node.attributes[0], scope)
if item != None:
(NA, varname, arguments, returnType, offset, scopefound) = item
else:
print("Function " + node.attributes[0] + " Not found")
sys.exit()
arguments = flatten(arguments)
if 2 * (len(node.children)) == len(arguments):
value = 1
for child in node.children:
if arguments[value] == "M_int":
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (arguments[value] == "M_bool"):
newNode.addChild(wf_I_expr(child, "Bool", scope))
else:
print("Invalid Argument Type")
sys.exit()
value += 2
return newNode
else:
print("Improper number of arguments in function call")
if (returnType == "M_int" and (type == "Int" or type == "Print")):
return newNode
elif (returnType == "M_bool" and (type == "Bool" or type == "Print")):
return newNode
else:
print("Function call return type does not match type of calling code")
sys.exit()
class App(object):
def __init__(self):
print("Creando nodos: ", end='')
self.i = Node("I", 7)
self.a = Node("A", 6)
self.b = Node("B", 2)
self.c = Node("C", 1)
self.f = Node("F", 0)
self.i.addChild(self.a, 1)
self.i.addChild(self.b, 4)
print("I ", end='')
self.a.addChild(self.b, 2)
self.a.addChild(self.c, 5)
self.a.addChild(self.f, 12)
print("A ", end='')
self.b.addChild(self.c, 2)
print("B ", end='')
self.c.addChild(self.f, 3)
print("C ", end='')
print("F ", end='')
def searchAStarAlgorithm(self):
print("\nBuscando ruta optima con Algoritmo A*")
astar = AStarAlgorithm(self.i, self.f)
print("Nodo Inicial: %s -----> Nodo Final %s" %
(self.i.name, self.f.name))
astar.run()
def wf_I_Int(node, scope):
if (node.name == "M_mul"):
newNode = Node("IMUL")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_add"):
newNode = Node("IADD")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_sub"):
newNode = Node("ISUB")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_div"):
newNode = Node("IDIV")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_neg"):
newNode = Node("INEG")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
else:
print("Expected Integer expression but got " + node.name + " Instead")
sys.exit()
return newNode
def generateTree(self, indsize=3):
default = "def namedfunc(x):\n\t"
rootNode = Node(default)
returnNode = Node("\n\treturn ")
self.pickChild(rootNode, rootNode)
rootNode.addChild(returnNode)
self.pickChild(returnNode, rootNode)
return rootNode
def startTree(carState):
"""
This function starts the creation of the tree of paths.
carState: the initial state of the car before starting the search for
an optimal path
"""
root = Node(0, [])
root.addChild(generateChildren(root, carState, 0, []))
def getNode(self, k, gDict = None): if k not in self._nodeMap: newNode = Node(k) self._nodeMap[k] = newNode for v in gDict[k]: newNode.addChild(self.getNode(v, gDict)) return self._nodeMap[k]
def wf_iBLOCK(node, scope):
newNode = Node("iBlock")
tally = 0
for child in node.children:
if child.name == "M_fun":
newNode.addChild(wf_I_fbody(child, scope))
elif child.name == "M_var":
tally += 1
else:
newNode.addChild(wf_I_stmt(child, scope))
newNode.addAttribute(tally)
return newNode
def wf_I_prog(node):
if node.name == "M_prog":
newNode = Node("IPROG")
table = getTable("Prog")
newNode.addAttribute(table.numberOfLocal)
for child in node.children:
if (child.name == "M_fun"):
newNode.addChild(wf_I_fbody(child, 0))
for child in node.children:
if (child.name != "M_var" and child.name != "M_fun"):
newNode.addChild(wf_I_stmt(child, 0))
return newNode
def wf_I_opn(node, type, scope):
if (node.name == "M_fn"):
newNode = wf_ICALL(node, type, scope)
elif (node.name == "M_app"):
newNode = Node("IAPP")
newNode.addChild(wf_I_opn(node.children[0], type, scope))
elif (type == "Int"):
newNode = wf_I_Int(node, scope)
elif (type == "Bool"):
newNode = wf_I_Bool(node, scope)
else:
print("incompatible type and expression")
sys.exit()
return newNode
def wf_IASS(node, scope):
newNode = Node("IASS")
item = lookup(node.attributes[0], scope)
if (item == None):
print("Variable " + node.attributes[0] + " not found for assignment")
sys.exit()
else:
(type, varname, varType, offset, scopefound) = item
newNode.addAttribute(node.attributes[0])
newNode.addAttribute(offset)
if (varType == "M_int"):
newNode.addChild(wf_I_expr(node.children[0], "Int", scope))
elif (varType == "M_bool"):
newNode.addChild(wf_I_expr(node.children[0], "Bool", scope))
return newNode
def wf_iRETURN(node, name, scope):
item = lookup(name, scope)
if item == None:
print("Something wrong with return statements")
sys.exit()
else:
newNode = Node("iRETURN")
(type, varname, arguments, returnType, offset, scopefound) = item
if (returnType == "M_int"):
newNode.addChild(wf_I_expr(node.children[0], "Int", scope))
elif (returnType == "M_bool"):
newNode.addChild(wf_I_expr(node.children[0], "Bool", scope))
else:
print("Unsupported return type: " + returnType)
sys.exit()
return newNode
def testContainsGrandChildNode(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
grandChild1 = Node("grandChild1")
grandChild2 = Node("grandChild2")
grandChild3 = Node("grandChild3")
root.addChild(child1)
root.addChild(child2)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
self.assertTrue(self.tree.contains(grandChild1))
self.assertTrue(self.tree.contains(grandChild2))
self.assertFalse(self.tree.contains(grandChild3))
def testContainsGrandChildNode(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
grandChild1 = Node("grandChild1")
grandChild2 = Node("grandChild2")
grandChild3 = Node("grandChild3")
root.addChild(child1)
root.addChild(child2)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
self.assertTrue(self.tree.contains(grandChild1))
self.assertTrue(self.tree.contains(grandChild2))
self.assertFalse(self.tree.contains(grandChild3))
def p_fun_body(p):
'''fun_body : BEGIN prog_stmts RETURN expr SEMICOLON END
| prog_stmts RETURN expr SEMICOLON'''
if len(p) == 7:
ret = Node("M_return")
ret.addChild(p[4])
if p[2] is not None:
p[0] = p[2], ret
else:
p[0] = ret
else:
ret = Node("M_return")
ret.addChild(p[3])
if p[1] is not None:
p[0] = p[1], ret
else:
p[0] = ret
def build(self):
with open(self.data) as f:
mvn_result = f.read()
nodeList = mvn_result.split('\n')
parent = Node(nodeList[0])
self.tree = Tree(parent)
for rawNode in nodeList[1:]:
level = self.computeLevel(rawNode)
child = Node(rawNode)
while (parent.getLevel() >= level):
parent = parent.getParent()
parent.addChild(child)
parent = child
return self.tree
def testFindGrandChildNode(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
grandChild1 = Node("grandChild1")
grandChild2 = Node("grandChild2")
grandChild3 = Node("grandChild3")
root.addChild(child1)
root.addChild(child2)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
foundGC1 = self.tree.find(grandChild1)
foundGC2 = self.tree.find(grandChild2)
self.assertEquals("grandChild1", foundGC1.getData())
self.assertEquals("grandChild2", foundGC2.getData())
self.assertEquals(None, self.tree.find(grandChild3))
def testFindGrandChildNode(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
grandChild1 = Node("grandChild1")
grandChild2 = Node("grandChild2")
grandChild3 = Node("grandChild3")
root.addChild(child1)
root.addChild(child2)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
foundGC1 = self.tree.find(grandChild1)
foundGC2 = self.tree.find(grandChild2)
self.assertEquals("grandChild1", foundGC1.getData())
self.assertEquals("grandChild2", foundGC2.getData())
self.assertEquals(None, self.tree.find(grandChild3))
def __generateDT(self, dataPartition, attributeList):
node = Node()
attributeListFromDataSet = list(map(lambda measurement: measurement.getPrediction(), dataPartition))
attributeDistribution = {i: attributeListFromDataSet.count(i) for i in set(attributeListFromDataSet)}
if len(set(map(lambda measurement: measurement.getPrediction(), dataPartition))) == 1:
node.setLeaf()
node.setLabel(dataPartition[0].getPrediction())
return node
else:
if not attributeList:
node.setLeaf()
node.setLabel(max(attributeDistribution.items(), key=lambda x: x[1])[0])
return node
else:
separationAttribute = self.__AttributeSelection(dataPartition, attributeList)
node.setLabel(self.__attributeDictionary[separationAttribute])
for value in self.__giniOutcome:
newDataPartition = \
list(filter(lambda measurement:
(measurement.getMeasurements()[separationAttribute] >=
self.__giniValues[separationAttribute]) == value,
dataPartition))
if not newDataPartition:
newChild = Node()
newChild.setLeaf()
newChild.setLabel(max(attributeDistribution.items(), key=lambda x: x[1])[0])
node.addChild(newChild)
node.addValueBranch(value)
else:
node.addChild(self.__generateDT(newDataPartition,
list(set(attributeList) - {separationAttribute})))
node.addValueBranch(value)
return node
def wf_I_fbody(current, scope):
for child in current.children:
if child.name == "M_block":
scope = scope + 1
newNode = Node("IFUN")
table = getTable(current.attributes[0])
if (table == None):
print("function " + current.attributes[0] +
" not defined in current scope")
sys.exit()
newNode.addAttribute(current.attributes[0])
newNode.addAttribute(table.numberOfLocal)
newNode.addAttribute(table.numberOfArguments)
for tiny in child.children:
if (tiny.name == "M_return"):
newNode.addChild(
wf_iRETURN(tiny, current.attributes[0], scope))
elif (tiny.name == "M_fun"):
newNode.addChild(wf_I_fbody(tiny, scope))
elif (tiny.name != "M_var" and tiny.name != "M_fun"):
newNode.addChild(wf_I_stmt(tiny, scope))
return newNode
def generateTree(self, data, attributes):
node = Node()
if self.__checkSameClass(data):
node.setLabel(data[0].getResult())
return node
else:
if attributes == []:
label = self.__getMajority(data)
node.setLabel(label)
return node
else:
sepparationAttribute = self.__attributeSelection(
data, attributes)
node.setLabel(sepparationAttribute)
for v in [1, 2, 3, 4, 5]:
listData = []
for d in data:
if sepparationAttribute == "lw" and d.getLW() == v:
listData.append(d)
if sepparationAttribute == "ld" and d.getLD() == v:
listData.append(d)
if sepparationAttribute == "rw" and d.getRW() == v:
listData.append(d)
if sepparationAttribute == "rd" and d.getRD() == v:
listData.append(d)
#pre pruning
if listData == [] or len(listData) == len(data) or len(
listData) == 2 * len(data) or len(listData) < 5:
newNode = Node()
label = self.__getMajority(data)
newNode.setLabel(label)
node.addChild(newNode)
return node
else:
copyA = copy.deepcopy(attributes)
copyA.remove(sepparationAttribute)
newNode = self.generateTree(listData, copyA)
node.addChild(newNode)
return node
def makeTree(self, curPlayer, move, depth):
root = Node()
moves = self.getVaildMoves(curPlayer)
if (depth == 0 or len(moves) == 0):
v = self.evaluate()
if curPlayer == 2:
v *= -1
root.setVal(v)
#print('v:' + str(v), end = " ")
root.setMove(move)
#if move is not None:
#print(move.toString(), end = " ")
if depth > 0:
for m in moves:
self.move(m)
if curPlayer == 1:
curPlayer = 2
else:
curPlayer = 1
root.addChild(self.makeTree(curPlayer, m, depth - 1))
self.unmove(m)
return root
def wf_I_APP(node, type, scope):
newNode = Node("IAPP")
if (node.name == "M_fn"):
newNode.addChild(wf_ICALL(node, type, scope))
return newNode
elif (node.name == "M_app"):
newNode.addChild(wf_I_opn(node.children[0], type, scope))
return newNode
else:
newNode.addChild(wf_I_opn(node, type, scope))
return newNode
def setUp(self):
self.bfs=BFS()
tree=Tree()
node1=Node()
node1.setValue(1)
node2=Node()
node2.setValue(2)
node3=Node()
node3.setValue(3)
node4=Node()
node4.setValue(4)
node5=Node()
node5.setValue(5)
node1.addChild(node2)
node1.addChild(node3)
node2.addChild(node4)
node3.addChild(node5)
node4.addChild(node2)
tree.setRoot(node1)
self.bfs.setTree(tree)
def setUp(self):
self.bfs = BFS()
tree = Tree()
node1 = Node()
node1.setValue(1)
node2 = Node()
node2.setValue(2)
node3 = Node()
node3.setValue(3)
node4 = Node()
node4.setValue(4)
node5 = Node()
node5.setValue(5)
node1.addChild(node2)
node1.addChild(node3)
node2.addChild(node4)
node3.addChild(node5)
node4.addChild(node2)
tree.setRoot(node1)
self.bfs.setTree(tree)
def __makeCallGraph(self,lines):
for index in range(len(lines)):
if lines[index].startswith('===>'):
classname ,methodname = self.__patternMethod(lines[index][4:])
# print classname
# print methodname
parentNode = Node(classname,methodname)
if parentNode.getHash() not in self.__nodes:
self.__nodes[parentNode.getHash()] = parentNode
# for key in self.__nodes.keys():
# print self.__nodes[key].getClassName()
# print self.__nodes[key].getMethodName()
# print self.__nodes[key].getChildList()
else:
parentNode = self.__nodes[parentNode.getHash()]
childstate = lines[index+1]
if 'invoke' not in childstate:#没有invoke认为赋值语句
if 'return' in childstate:#如果是return 说明return的上一句是return下一句的父节点
# print childstate
childchildstate = lines[index + 2]
classname, methodname = self.__patternMethod(childchildstate[4:])
gradepaNode = Node(classname, methodname)
if gradepaNode.getHash() not in self.__nodes:
self.__nodes[gradepaNode.getHash()] = gradepaNode
gradepaNode.addChild(parentNode)
else:
gradepaNode = self.__nodes[gradepaNode.getHash()]
gradepaNode.addChild(parentNode)
else:
temp = self.__patternNode(childstate[7:])
if temp is None:
continue
classname ,methodname = self.__splitNodestr(temp)
# print classname
# print methodname
childNode = Node(classname,methodname)
self.__nodes[childNode.getHash()] = childNode
parentNode.addChild(childNode)
if lines[index].startswith('------>'):
pass
def wf_I_Bool(node, scope):
if (node.name == "M_eq"):
newNode = Node("IEQ")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_ge"):
newNode = Node("IGE")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_gt"):
newNode = Node("IGT")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_le"):
newNode = Node("ILE")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_lt"):
newNode = Node("ILT")
for child in node.children:
newNode.addChild(wf_I_expr(child, "Int", scope))
elif (node.name == "M_and"):
newNode = Node("IAND")
for child in node.children:
newNode.addChild(wf_I_opn(child, "Bool", scope))
elif (node.name == "M_not" and type == "Bool"):
newNode = Node("INOT")
for child in node.children:
newNode.addChild(wf_I_opn(child, "Bool", scope))
elif (node.name == "M_or" and type == "Bool"):
newNode = Node("IOR")
for child in node.children:
newNode.addChild(wf_I_opn(child, "Bool", scope))
else:
print("Expected boolean expression but got " + node.name + " Instead")
sys.exit()
return newNode
def testFoundNodeBuildWithChildren(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
foundNode = self.tree.find(Node("child2"))
expectedString = ("1 child2\n"
"2 grandChild2\n"
"3 descendant2\n"
"3 descendant22\n")
self.assertEquals(expectedString, foundNode.buildWithChildren(True))
def testContainsDescendantNodes(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
self.assertTrue(self.tree.contains(Node("descendant1")))
self.assertTrue(self.tree.contains(Node("descendant11")))
self.assertTrue(self.tree.contains(Node("descendant2")))
self.assertTrue(self.tree.contains(Node("descendant22")))
self.assertFalse(self.tree.contains(descendant3))
def wf_print(current, scope):
newNode = Node("IPRINT")
newNode.addChild(wf_I_expr(current.children[0], "Print", scope))
return newNode
def wf_ICOND(node, scope):
newNode = Node("ICOND")
newNode.addChild(wf_I_expr(node.children[0], "Bool", scope))
newNode.addChild(wf_I_stmt(node.children[1], scope))
newNode.addChild(wf_I_stmt(node.children[2], scope))
return newNode
def testTreeToString(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
expectedString = ( "0 hello world\n"
"1 child1\n"
"2 grandChild1\n"
"3 descendant1\n"
"3 descendant11\n"
"1 child2\n"
"2 grandChild2\n"
"3 descendant2\n"
"3 descendant22\n"
"1 child3\n")
self.assertEquals(expectedString, self.tree.toString(True))
def testContainsDescendantNodes(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
self.assertTrue(self.tree.contains(Node("descendant1")))
self.assertTrue(self.tree.contains(Node("descendant11")))
self.assertTrue(self.tree.contains(Node("descendant2")))
self.assertTrue(self.tree.contains(Node("descendant22")))
self.assertFalse(self.tree.contains(descendant3))
def testFoundNodeBuildWithChildren(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
foundNode = self.tree.find(Node("child2"))
expectedString = ( "1 child2\n"
"2 grandChild2\n"
"3 descendant2\n"
"3 descendant22\n")
self.assertEquals(expectedString, foundNode.buildWithChildren(True))
def testTreeToString(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
expectedString = ("0 hello world\n"
"1 child1\n"
"2 grandChild1\n"
"3 descendant1\n"
"3 descendant11\n"
"1 child2\n"
"2 grandChild2\n"
"3 descendant2\n"
"3 descendant22\n"
"1 child3\n")
self.assertEquals(expectedString, self.tree.toString(True))
def testFindDescendantNodes(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
foundD1 = self.tree.find(Node("descendant1"))
foundD11 = self.tree.find(Node("descendant11"))
foundD2 = self.tree.find(Node("descendant2"))
foundD22 = self.tree.find(Node("descendant22"))
self.assertEquals(descendant1.getData(), foundD1.getData())
self.assertEquals(descendant11.getData(), foundD11.getData())
self.assertEquals(descendant2.getData(), foundD2.getData())
self.assertEquals(descendant22.getData(), foundD22.getData())
self.assertEquals(None, self.tree.find(descendant3))
def testFindDescendantNodes(self):
root = self.tree.getRoot()
child1 = Node("child1")
child2 = Node("child2")
child3 = Node("child3")
grandChild1 = Node("grandChild1")
grandChild11 = Node("grandChild11")
grandChild2 = Node("grandChild2")
grandChild22 = Node("grandChild22")
descendant1 = Node("descendant1")
descendant11 = Node("descendant11")
descendant2 = Node("descendant2")
descendant22 = Node("descendant22")
descendant3 = Node("descendant3")
root.addChild(child1)
root.addChild(child2)
root.addChild(child3)
child1.addChild(grandChild1)
child2.addChild(grandChild2)
grandChild1.addChild(descendant1)
grandChild1.addChild(descendant11)
grandChild2.addChild(descendant2)
grandChild2.addChild(descendant22)
foundD1 = self.tree.find(Node("descendant1"))
foundD11 = self.tree.find(Node("descendant11"))
foundD2 = self.tree.find(Node("descendant2"))
foundD22 = self.tree.find(Node("descendant22"))
self.assertEquals(descendant1.getData(), foundD1.getData())
self.assertEquals(descendant11.getData(), foundD11.getData())
self.assertEquals(descendant2.getData(), foundD2.getData())
self.assertEquals(descendant22.getData(), foundD22.getData())
self.assertEquals(None, self.tree.find(descendant3))
def wf_IWHILE(node, scope):
newNode = Node("IWHILE")
newNode.addChild(wf_I_expr(node.children[0], "Bool", scope))
newNode.addChild(wf_I_stmt(node.children[1], scope))
return newNode
'''
@author: Devangini Patel
'''
from Node import Node
from State import State
initialState = State()
root = Node(initialState)
childStates = initialState.successorFunction()
for childState in childStates:
childNode = Node(State(childState))
root.addChild(childNode)
root.printTree()
