Exemple #1
0
 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)])
Exemple #2
0
 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)])
Exemple #3
0
 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)
Exemple #5
0
    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)])
Exemple #6
0
 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)
Exemple #8
0
 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)
Exemple #9
0
 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)