def infer_automata(sequences):
__graph__ = Graph([StartNode, EndNode], [])
for sequence in sequences:
last = StartNode
for item in sequence:
__graph__.addnode(item)
__graph__.createedge(last, item)
last = item
__graph__.createedge(last, EndNode)
return __graph__
class NodesTests(unittest.TestCase):
def setUp(self):
self.graph = Graph(nodes = range(1, 10))
def testLenWhenInitNodeArgument(self):
self.assertEqual(len(self.graph), len(range(1, 10)))
def testLenWhenAddedNode(self):
previouslen = len(self.graph)
self.graph.addnode(1000)
self.assertEqual(len(self.graph), previouslen + 1)
def testLenWhenNonAddedNode(self):
previouslen = len(self.graph)
self.graph.addnode(1)
self.assertEqual(len(self.graph), previouslen)
def testLenWhenRemovedNode(self):
previouslen = len(self.graph)
self.graph.removenode(1)
self.assertEqual(len(self.graph), previouslen - 1)
def testLenWhenNonRemovedNode(self):
previouslen = len(self.graph)
self.graph.removenode(1000)
self.assertEqual(len(self.graph), previouslen)
def testAddedNode(self):
self.graph.addnode(1)
self.assert_(1 in self.graph.nodes)
def testRemovedNode(self):
self.graph.removenode(5)
self.assert_(5 not in self.graph.nodes)
class IDTDTests(unittest.TestCase):
def setUp(self):
# Graph from Figure 2 in [Bex2006]
self.tree = Graph(nodes = "abcde")
self.tree.addnode(StartNode)
self.tree.addnode(EndNode)
# StartNode
self.tree.addedge((StartNode, 'b'))
self.tree.addedge((StartNode, 'c'))
# Node `a`
self.tree.addedge(('a', 'c'))
# Node `b`
self.tree.addedge(('b', 'a'))
# Node `c`
self.tree.addedge(('c', 'a'))
self.tree.addedge(('c', 'b'))
self.tree.addedge(('c', 'd'))
# Node `d`
self.tree.addedge(('d', 'a'))
self.tree.addedge(('d', 'b'))
self.tree.addedge(('d', 'e'))
# Node `e`
self.tree.addedge(('e', EndNode))
self.cycle = Graph(nodes = "abc")
self.cycle.addnode(StartNode)
self.cycle.addnode(EndNode)
for x in "abc":
self.cycle.addedge((StartNode, x))
self.cycle.addedge((x, EndNode))
self.cycle.addedge(('a', 'b'))
self.cycle.addedge(('b', 'c'))
self.cycle.addedge(('c', 'a'))
def testEnableDisjunction(self):
__enable_disjunction_for_nodes__(self.tree, ['a', 'c'])
self.assert_(Disjunction(('a', 'c')) in self.tree.nodes)
def testEnableDisjunctionPreconditionB(self):
self.assertEqual(__enable_disjunction_case_b__(self.tree), True)
self.assert_(Disjunction(('a', 'c')) in self.tree.nodes)
self.assertEqual(__enable_disjunction_case_b__(self.cycle), False)
def testEnableDisjunctionPreconditionACycle(self):
self.assertEqual(__enable_disjunction_case_a__(self.cycle), True)
self.assert_(Disjunction(('a', 'b')) in self.cycle.nodes or
Disjunction(('b', 'c')) in self.cycle.nodes or
Disjunction(('a', 'c')) in self.cycle.nodes)
self.assertEqual(__enable_disjunction_case_a__(self.tree), False)
def testEnableOptionalB(self):
self.assert_(('c', 'a') in self.tree.edges)
self.assert_(('d', 'a') in self.tree.edges)
__enable_optional_for_node__(self.tree, 'b')
self.assert_(Optional('b') in self.tree.nodes)
self.assert_((Optional('b'), 'a') in self.tree.edges)
self.assert_(('c', 'a') not in self.tree.edges)
self.assert_(('d', 'a') not in self.tree.edges)
self.assert_((StartNode, 'a') not in self.tree.edges)
def testEnableOptionalPreconditionA(self):
self.assertEqual(__enable_optional_case_a__(self.tree), True)
self.assert_(Optional('b') in self.tree.nodes or
Optional('c') in self.tree.nodes or
Optional('d') in self.tree.nodes)
def testEnableOptionalPreconditionB(self):
self.assertEqual(__enable_optional_case_b__(self.tree), True)
self.assert_(Optional('e') in self.tree.nodes)
self.assertEqual(__enable_optional_case_b__(self.tree), False)
def testIDT(self):
self.assert_(infer_soa(self.tree))
self.assert_(infer_soa(self.cycle))
class RewriteTests(unittest.TestCase):
def prepareTree(self):
# Graph from Figure 2 in [Bex2006]
self.tree = Graph(nodes = "abcde")
self.tree.addnode(StartNode)
self.tree.addnode(EndNode)
# StartNode
self.tree.addedge((StartNode, 'b'))
self.tree.addedge((StartNode, 'c'))
# Node `a`
self.tree.addedge(('a', 'c'))
# Node `b`
self.tree.addedge(('b', 'a'))
# Node `c`
self.tree.addedge(('c', 'a'))
self.tree.addedge(('c', 'b'))
self.tree.addedge(('c', 'd'))
# Node `d`
self.tree.addedge(('d', 'a'))
self.tree.addedge(('d', 'b'))
self.tree.addedge(('d', 'e'))
# Node `e`
self.tree.addedge(('e', EndNode))
def prepareGraph(self):
# Graph from Figure 1 in [Bex2006]
self.graph = Graph(nodes = "abcde")
self.graph.addnode(StartNode)
self.graph.addnode(EndNode)
# StartNode
self.graph.addedge((StartNode, 'a'))
self.graph.addedge((StartNode, 'b'))
self.graph.addedge((StartNode, 'c'))
# Node `a`
self.graph.addedge(('a', 'a'))
self.graph.addedge(('a', 'b'))
self.graph.addedge(('a', 'c'))
self.graph.addedge(('a', 'd'))
# Node `b`
self.graph.addedge(('b', 'a'))
self.graph.addedge(('b', 'c'))
# Node `c`
self.graph.addedge(('c', 'a'))
self.graph.addedge(('c', 'b'))
self.graph.addedge(('c', 'c'))
self.graph.addedge(('c', 'd'))
# Node `d`
self.graph.addedge(('d', 'b'))
self.graph.addedge(('d', 'e'))
self.graph.addedge(('d', 'a'))
self.graph.addedge(('d', 'c'))
# Node `e`
self.graph.addedge(('e', EndNode))
def prepareRandomGraph(self):
import random
size = random.randint(10, 20)
self.rndgraph = Graph(nodes = range(1, size))
for source in xrange(1, size):
for target in xrange(source, size):
if random.random() > 0.5:
self.rndgraph.addedge((source, target))
def setUp(self):
self.prepareTree()
self.prepareGraph()
# self.prepareRandomGraph()
def testSelfLoop(self):
self.assertEqual(__selflooprule__(self.graph), True)
def testOptionalRuleApplied(self):
self.assertEqual(__optionalrule__(self.graph), True)
self.assert_('b' not in self.graph.nodes)
self.assert_(Optional('b') in self.graph.nodes)
def testDisjunctionRuleApplied(self):
__optionalrule__(self.graph)
self.assertEqual(__disjunctionrule__(self.graph), True)
self.assert_(Disjunction(('a', 'c')) in self.graph.nodes)
def testConjunctionRuleApplied(self):
__optionalrule__(self.graph)
__disjunctionrule__(self.graph)
self.assertEqual(__concatrule__(self.graph), True)
self.assert_(Conjunction([Optional('b'), Disjunction(['c', 'a'])]) in self.graph.nodes)
def testNonApplicableConcat(self):
self.assertEqual(__concatrule__(self.tree), False)
self.assertEqual(len(self.tree), 7)
def testNonApplicableDisjunction(self):
self.assertEqual(__disjunctionrule__(self.tree), False)
self.assertEqual(len(self.tree), 7)
def testNonApplicableOptional(self):
self.assertEqual(__optionalrule__(self.tree), False)
self.assertEqual(len(self.tree), 7)
def testNonApplicableSelfLoop(self):
self.assertEqual(__selflooprule__(self.tree), False)
self.assertEqual(len(self.tree), 7)
def testLengthNonAumented(self):
self.prepareRandomGraph()
previouslen = len(self.rndgraph)
rewrite(self.rndgraph)
self.assert_(previouslen >= len(self.rndgraph))
