def test_difference(self): coverage_set = [CoverageSet() for i in xrange(3)] coverage_set[0].add(15, 30) coverage_set[0].add(35, 50) coverage_set[1].add(25, 40) coverage_set[1].add(45, 60) coverage_set[2].add(0, 5) coverage_set[2].add(10, 20) difference = CoverageSet.difference(coverage_set[0], *coverage_set[1:3]) self.assertEqual([i for i in difference], [(21, 24), (41, 44)])
def test_union(self): coverage_set = [CoverageSet() for i in xrange(3)] coverage_set[0].add(25, 42) coverage_set[0].add(15, 16) coverage_set[1].add(16, 30) coverage_set[1].add(30, 35) coverage_set[1].add(99, 100) coverage_set[2].add(37, 40) coverage_set[2].add(39, 41) union = CoverageSet.union(*coverage_set) self.assertEqual([i for i in union], [(15, 42), (99, 100)])
def test_overlap_removal(self): coverage_set = CoverageSet() coverage_set.add(25, 42) coverage_set.add(43, 46) coverage_set.add(16, 30) coverage_set.add(98, 101) coverage_set.add(18, 20) coverage_set.add(15, 16) intervals = [i for i in coverage_set] expected = [(15, 46), (98, 101)] for i, j in zip(intervals, expected): self.assertEqual(i, j)
def get_simple_dfa(): # Identical DFAs dfa = Automata.DeterministicFinite() dfa_s = [Automata.DeterministicState() for i in xrange(4)] dfa_s[0].edges[dfa_s[1]] = CoverageSet([(0, 1), (2, 3)]) dfa_s[1].edges[dfa_s[2]] = CoverageSet([(0, 1), (2, 3)]) dfa_s[1].edges[dfa_s[3]] = CoverageSet([(5, 7)]) dfa_s[2].is_final = True dfa_s[2].final_ids = set(['Hello', 'Goodbye']) dfa_s[3].is_final = True dfa_s[3].final_ids = set(['Goodbye']) dfa.start_state = dfa_s[0] return (dfa, dfa_s)
def test_intersection(self): coverage_set = [CoverageSet() for i in xrange(3)] coverage_set[0].add(25, 42) coverage_set[0].add(15, 16) coverage_set[1].add(16, 30) coverage_set[1].add(30, 35) coverage_set[2].add(37, 40) coverage_set[2].add(39, 41) intersection = CoverageSet.intersection(*coverage_set) self.assertEqual([i for i in intersection], []) coverage_set[2].add(31, 36) intersection2 = CoverageSet.intersection(*coverage_set) self.assertEqual([i for i in intersection2], [(31, 35)])
def test_segmentation(self): coverage_set = [CoverageSet() for i in xrange(3)] coverage_set[0].add(25, 42) coverage_set[0].add(15, 16) coverage_set[1].add(16, 30) coverage_set[1].add(30, 35) coverage_set[2].add(37, 40) coverage_set[2].add(39, 41) expected = [ ((15, 15), set(['0'])), ((16, 16), set(['1', '0'])), ((17, 24), set(['1'])), ((25, 35), set(['1', '0'])), ((36, 36), set(['0'])), ((37, 41), set(['0', '2'])), ((42, 42), set(['0'])) ] segments = CoverageSet.segments(*[(cset, str(i)) for i, cset in enumerate(coverage_set)]) for ((expected_segment, expected_idset), (segment, idset)) in zip(expected, segments): self.assertEqual(expected_segment, segment) self.assertEqual(expected_idset, idset)
def test_lexical_analyzer(self): # Generate DFA through the LexicalAnalyzer class rules_file = AST.Section( "::main::", None, rule=[ AST.Rule( "keyword", AST.Pattern(ur'k€yword', AST.PatternAttributes(True, False, False))), AST.Rule( "identifier", AST.Pattern(ur'[a-zA-Z][a-zA-Z0-9€_]*', AST.PatternAttributes(True, False, False))), AST.Rule("float", AST.Pattern(ur'[0-9]+\.[0-9]*|[0-9]*\.[0-9]+')), AST.Rule("integer", AST.Pattern(ur'[[:digit:]]+')), AST.Rule("quote", AST.Pattern(ur'"([^"\\]|\\.)*"')), AST.Rule("newline", AST.Pattern(ur'\r\n|\r|\n')), AST.Rule("whitespace", AST.Pattern(ur'[\t\s]+')) ]) nfa_ir = NonDeterministicIR(rules_file) dfa_ir = DeterministicIR(nfa_ir) # Compare DFA to expected minimized DFA expected_dfa = Automata.DeterministicFinite() dfa_s = [Automata.DeterministicState() for i in xrange(18)] #Start state dfa_s[0].ids = hash_ids("float", "whitespace", "keyword", "integer", "quote", "identifier", "newline") #quote dfa_s[0].edges[dfa_s[2]] = CoverageSet([(34, 34)]) dfa_s[2].is_final = False dfa_s[2].ids = hash_ids("quote") dfa_s[2].edges[dfa_s[10]] = CoverageSet([(92, 92)]) dfa_s[2].edges[dfa_s[2]] = CoverageSet([(1, 33), (35, 91), (93, 0x10FFFF)]) dfa_s[10].is_final = False dfa_s[10].ids = hash_ids("quote") dfa_s[10].edges[dfa_s[2]] = CoverageSet([(1, 0x10FFFF)]) dfa_s[2].edges[dfa_s[9]] = CoverageSet([(34, 34)]) dfa_s[9].is_final = True dfa_s[9].final_ids = hash_ids("quote") dfa_s[9].ids = hash_ids("quote") #newline dfa_s[0].edges[dfa_s[3]] = CoverageSet([(13, 13)]) dfa_s[0].edges[dfa_s[1]] = CoverageSet([(10, 10)]) dfa_s[3].is_final = True dfa_s[3].ids = hash_ids("newline") dfa_s[3].final_ids = hash_ids("newline") dfa_s[3].edges[dfa_s[1]] = CoverageSet([(10, 10)]) dfa_s[1].is_final = True dfa_s[1].ids = hash_ids("newline") dfa_s[1].final_ids = hash_ids("newline") #identifier dfa_s[0].edges[dfa_s[5]] = CoverageSet([(65, 74), (76, 90), (97, 106), (108, 122)]) dfa_s[5].is_final = True dfa_s[5].ids = hash_ids("identifier") dfa_s[5].final_ids = hash_ids("identifier") dfa_s[5].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 90), (95, 95), (97, 122), (0x20ac, 0x20ac)]) #integer dfa_s[0].edges[dfa_s[4]] = CoverageSet([(48, 57)]) dfa_s[4].is_final = True dfa_s[4].ids = hash_ids("integer", "float") dfa_s[4].final_ids = hash_ids("integer") dfa_s[4].edges[dfa_s[4]] = CoverageSet([(48, 57)]) dfa_s[4].edges[dfa_s[11]] = CoverageSet([(46, 46)]) #float dfa_s[0].edges[dfa_s[6]] = CoverageSet([(46, 46)]) dfa_s[6].is_final = False dfa_s[6].ids = hash_ids("float") dfa_s[6].edges[dfa_s[11]] = CoverageSet([(48, 57)]) dfa_s[11].is_final = True dfa_s[11].ids = hash_ids("float") dfa_s[11].final_ids = hash_ids("float") dfa_s[11].edges[dfa_s[11]] = CoverageSet([(48, 57)]) #whitespace dfa_s[0].edges[dfa_s[7]] = CoverageSet([(9, 9), (32, 32)]) dfa_s[7].is_final = True dfa_s[7].ids = hash_ids("whitespace") dfa_s[7].final_ids = hash_ids("whitespace") dfa_s[7].edges[dfa_s[7]] = CoverageSet([(9, 9), (32, 32)]) #keyword dfa_s[0].edges[dfa_s[8]] = CoverageSet([(75, 75), (107, 107)]) dfa_s[8].is_final = True dfa_s[8].ids = hash_ids("identifier", "keyword") dfa_s[8].final_ids = hash_ids("identifier") dfa_s[8].edges[dfa_s[12]] = CoverageSet([(0x20ac, 0x20ac)]) dfa_s[8].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 90), (95, 95), (97, 122)]) dfa_s[12].is_final = True dfa_s[12].ids = hash_ids("identifier", "keyword") dfa_s[12].final_ids = hash_ids("identifier") dfa_s[12].edges[dfa_s[13]] = CoverageSet([(121, 121), (89, 89)]) dfa_s[12].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 88), (90, 90), (95, 95), (97, 120), (122, 122), (0x20ac, 0x20ac)]) dfa_s[13].is_final = True dfa_s[13].ids = hash_ids("identifier", "keyword") dfa_s[13].final_ids = hash_ids("identifier") dfa_s[13].edges[dfa_s[14]] = CoverageSet([(119, 119), (87, 87)]) dfa_s[13].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 86), (88, 90), (95, 95), (97, 118), (120, 122), (0x20ac, 0x20ac)]) dfa_s[14].is_final = True dfa_s[14].ids = hash_ids("identifier", "keyword") dfa_s[14].final_ids = hash_ids("identifier") dfa_s[14].edges[dfa_s[15]] = CoverageSet([(111, 111), (79, 79)]) dfa_s[14].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 78), (80, 90), (95, 95), (97, 110), (112, 122), (0x20ac, 0x20ac)]) dfa_s[15].is_final = True dfa_s[15].ids = hash_ids("identifier", "keyword") dfa_s[15].final_ids = hash_ids("identifier") dfa_s[15].edges[dfa_s[16]] = CoverageSet([(114, 114), (82, 82)]) dfa_s[15].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 81), (83, 90), (95, 95), (97, 113), (115, 122), (0x20ac, 0x20ac)]) dfa_s[16].is_final = True dfa_s[16].ids = hash_ids("identifier", "keyword") dfa_s[16].final_ids = hash_ids("identifier") dfa_s[16].edges[dfa_s[17]] = CoverageSet([(100, 100), (68, 68)]) dfa_s[16].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 67), (69, 90), (95, 95), (97, 99), (101, 122), (0x20ac, 0x20ac)]) dfa_s[17].is_final = True dfa_s[17].ids = hash_ids("identifier", "keyword") dfa_s[17].final_ids = hash_ids("identifier", "keyword") dfa_s[17].edges[dfa_s[5]] = CoverageSet([(48, 57), (65, 90), (95, 95), (97, 122), (0x20ac, 0x20ac)]) expected_dfa.start_state = dfa_s[0] self.assertEqual(dfa_ir.sections.values()[0].dfa, expected_dfa)
def test_minimization_simple(self): dfa = Automata.DeterministicFinite() states = [Automata.DeterministicState() for i in xrange(9)] states[0].edges[states[1]] = CoverageSet([(1, 1)]) states[0].edges[states[2]] = CoverageSet([(2, 2)]) states[0].edges[states[3]] = CoverageSet([(3, 3)]) states[1].edges[states[4]] = CoverageSet([(1, 3)]) states[2].edges[states[4]] = CoverageSet([(1, 3)]) states[3].edges[states[4]] = CoverageSet([(1, 3)]) states[4].edges[states[5]] = CoverageSet([(1, 1)]) states[4].edges[states[6]] = CoverageSet([(2, 2)]) states[4].edges[states[7]] = CoverageSet([(3, 3)]) states[5].edges[states[8]] = CoverageSet([(1, 3)]) states[6].edges[states[8]] = CoverageSet([(1, 3)]) states[7].edges[states[8]] = CoverageSet([(1, 1)]) dfa.start_state = states[0] states[8].is_final = True states[8].final_ids = set(['Final']) Minimizer.polynomial(dfa) min_dfa = Automata.DeterministicFinite() min_states = [Automata.DeterministicState() for i in xrange(6)] min_states[0].edges[min_states[1]] = CoverageSet([(1, 3)]) min_states[1].edges[min_states[2]] = CoverageSet([(1, 3)]) min_states[2].edges[min_states[3]] = CoverageSet([(1, 2)]) min_states[2].edges[min_states[4]] = CoverageSet([(3, 3)]) min_states[3].edges[min_states[5]] = CoverageSet([(1, 3)]) min_states[4].edges[min_states[5]] = CoverageSet([(1, 1)]) min_dfa.start_state = min_states[0] min_states[5].is_final = True min_states[5].final_ids = set(['Final']) self.assertEqual(dfa, min_dfa)
def test_minimization_complex(self): dfa = Automata.DeterministicFinite() states = [Automata.DeterministicState() for i in xrange(8)] states[0].edges[states[1]] = CoverageSet([(1, 1)]) states[0].edges[states[2]] = CoverageSet([(0, 0)]) states[1].edges[states[0]] = CoverageSet([(1, 1)]) states[1].edges[states[2]] = CoverageSet([(0, 0)]) states[2].edges[states[3]] = CoverageSet([(0, 1)]) states[3].edges[states[4]] = CoverageSet([(0, 0)]) states[3].edges[states[6]] = CoverageSet([(1, 1)]) states[4].edges[states[6]] = CoverageSet([(0, 0)]) states[4].edges[states[7]] = CoverageSet([(1, 1)]) states[5].edges[states[6]] = CoverageSet([(1, 1)]) states[5].edges[states[4]] = CoverageSet([(0, 0)]) states[6].edges[states[6]] = CoverageSet([(0, 1)]) states[7].edges[states[6]] = CoverageSet([(1, 1)]) states[7].edges[states[7]] = CoverageSet([(0, 0)]) dfa.start_state = states[0] states[6].is_final = True states[6].final_ids = set(['Final']) states[7].is_final = True states[7].final_ids = set(['Final']) dfa_copy = dfa.copy() Minimizer.polynomial(dfa) Minimizer.hopcroft(dfa_copy) min_dfa = Automata.DeterministicFinite() min_states = [Automata.DeterministicState() for i in xrange(5)] min_states[0].edges[min_states[0]] = CoverageSet([(1, 1)]) min_states[0].edges[min_states[1]] = CoverageSet([(0, 0)]) min_states[1].edges[min_states[2]] = CoverageSet([(0, 1)]) min_states[2].edges[min_states[3]] = CoverageSet([(0, 0)]) min_states[2].edges[min_states[4]] = CoverageSet([(1, 1)]) min_states[3].edges[min_states[4]] = CoverageSet([(0, 1)]) min_states[4].edges[min_states[4]] = CoverageSet([(0, 1)]) min_dfa.start_state = min_states[0] min_states[4].is_final = True min_states[4].final_ids = set(['Final']) self.assertEqual(dfa, min_dfa) self.assertEqual(dfa, dfa_copy)