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