class TestFA(unittest.TestCase): def setUp(self): print('Running ' + self._testMethodName) # L1 = {(a,b)* ^ no "aaa"} DFA Incompleto transitions = { "S": { 'a': {"A"}, 'b': {"S"} }, "A": { 'a': {"B"}, 'b': {"S"} }, "B": { 'b': {"S"} } } self.no_aaa = NFA(transitions, "S", {"S", "A", "B"}) self.no_aaa_accept = [ "", "a", "aa", "baa", "aabbaa", "bababaab", "bbb" ] self.no_aaa_reject = [ "aaaba", "bbbbaaab", "abaaa", "baaa", "aaa", "aaaa" ] # L2 = {(a,b)* ^ no "bbb"} DFA Incompleto transitions = { "S": { 'a': {"S"}, 'b': {"A"} }, "A": { 'a': {"S"}, 'b': {"B"} }, "B": { 'a': {"S"} } } self.no_bbb = NFA(transitions, "S", {"S", "A", "B"}) self.no_bbb_accept = [ "", "b", "bb", "abb", "bbaabb", "abababba", "aaa" ] self.no_bbb_reject = [ "bbbab", "aaaabbba", "babbb", "abbb", "bbb", "bbbb" ] # L3 = {(a,b)* ^ termina com "aa"} NFA Incompleto transitions = { "S": { 'a': {"S", "A"}, 'b': {"S"} }, "A": { 'a': {"B"} }, "B": {} } self.ends_in_aa = NFA(transitions, "S", {"B"}) self.ends_in_aa_accept = [ "babaa", "baa", "aaaa", "aa", "bababaa", "aabaa" ] self.ends_in_aa_reject = [ "baba", "aba", "aaba", "baaaaba", "bbbb", "aaab", "", "a" ] self.starts_with_aa = self.ends_in_aa.reverse() self.starts_with_aa_accept = [ reversed(s) for s in self.ends_in_aa_accept ] self.starts_with_aa_reject = [ reversed(s) for s in self.ends_in_aa_reject ] self.no_aaa_removed_B = { "S": { 'a': {"A"}, 'b': {"S"} }, "A": { 'a': set(), 'b': {"S"} }, } # L4 = {(a,b)* ^ #b's /3} DFA Completo transitions = { "A": { 'a': {'G'}, 'b': {'B'} }, "B": { 'a': {'F'}, 'b': {'E'} }, "C": { 'a': {'C'}, 'b': {'G'} }, "D": { 'a': {'A'}, 'b': {'H'} }, "E": { 'a': {'E'}, 'b': {'A'} }, "F": { 'a': {'B'}, 'b': {'C'} }, "G": { 'a': {'G'}, 'b': {'F'} }, "H": { 'a': {'H'}, 'b': {'D'} }, } self.b_div_3 = NFA(transitions, "A", {"A", "D", "G"}) self.b_div_3_accept = ["", "a", "aa", "bbb", "ababb", "babb"] self.b_div_3_reject = ["b", "bb", "bbbb", "babbb"] # L4 = {(a,b)* ^ no "aa"} DFA Completo transitions = { "S": { 'a': {"A"}, 'b': {"S"} }, "A": { 'a': {"B"}, 'b': {"S"} }, "B": { 'a': {"B"}, 'b': {"B"} }, } self.no_aa = NFA(transitions, "S", {"S", "A"}) # L4 = {(0,1)* ^ #0s>=1, #1s<=1} DFA Completo transitions = { "A": { '0': {'B'}, '1': {'D'} }, "B": { '0': {'A'}, '1': {'C'} }, "C": { '0': {'E'}, '1': {'F'} }, "D": { '0': {'E'}, '1': {'F'} }, "E": { '0': {'E'}, '1': {'F'} }, "F": { '0': {'F'}, '1': {'F'} }, } self.only_one_1 = NFA(transitions, "A", {"C", "D", "E"}) def check_strings(self, fa, accept, reject): for word in accept: self.assertTrue(fa.accepts(word)) for word in reject: self.assertFalse(fa.accepts(word)) def test_fa(self): self.check_strings(self.no_aaa, self.no_aaa_accept, self.no_aaa_reject) self.check_strings(self.no_bbb, self.no_bbb_accept, self.no_bbb_reject) def test_reverse(self): self.check_strings(self.starts_with_aa, self.starts_with_aa_accept, self.starts_with_aa_reject) def test_is_dfa(self): self.assertTrue(self.no_aaa.is_dfa()) self.assertTrue(self.no_bbb.is_dfa()) self.assertFalse(self.ends_in_aa.is_dfa()) def test_determinize(self): det = copy.deepcopy(self.ends_in_aa) det.determinize() self.check_strings(det, self.ends_in_aa_accept, self.ends_in_aa_reject) def test_complete(self): # Completar um DFA complete_1 = copy.deepcopy(self.no_aaa) complete_1.complete() self.check_strings(complete_1, self.no_aaa_accept, self.no_aaa_reject) #Completar um NFA complete_3 = copy.deepcopy(self.ends_in_aa) complete_3.complete() self.check_strings(complete_3, self.ends_in_aa_accept, self.ends_in_aa_reject) def test_complement(self): complement_1 = copy.deepcopy(self.no_aaa) complement_1.complement() self.check_strings(complement_1, self.no_aaa_reject, self.no_aaa_accept) complement_2 = copy.deepcopy(self.no_bbb) complement_2.complement() self.check_strings(complement_2, self.no_bbb_reject, self.no_bbb_accept) complement_3 = copy.deepcopy(self.ends_in_aa) complement_3.complement() self.check_strings(complement_3, self.ends_in_aa_reject, self.ends_in_aa_accept) def test_union(self): # União de dois DFA incompletos union_1 = self.no_aaa.union(self.no_bbb) union_1_accepts = list(set().union(self.no_aaa_accept, self.no_bbb_accept)) union_1_rejects = ["aaabbb", "abbbaaa"] self.check_strings(union_1, union_1_accepts, union_1_rejects) # União de DFA e NFA incompletos union_2 = self.no_aaa.union(self.ends_in_aa) #union_2.printer() union_2_accepts = list(set().union(self.no_aaa_accept, self.ends_in_aa_accept)) union_2_rejects = ["aaab", "aaabb", "aaaba"] self.check_strings(union_2, union_2_accepts, union_2_rejects) def test_rename(self): renamed_1 = copy.deepcopy(self.no_aaa) renamed_1.rename_states(0) self.check_strings(renamed_1, self.no_aaa_accept, self.no_aaa_reject) renamed_2 = copy.deepcopy(self.ends_in_aa) renamed_2.rename_states(0) self.check_strings(renamed_2, self.ends_in_aa_accept, self.ends_in_aa_reject) def test_intersection(self): # Intersecção de dois DFA incompletos inter_1 = self.no_aaa.intersection(self.no_bbb) inter_1_accepts = [ "a", "b", "aa", "bb", "ab", "ba", "aab", "bba", "aaba", "bbab", "" ] inter_1_rejects = list(set().union(self.no_aaa_reject, self.no_bbb_reject)) inter_1_rejects.append("aaabbb") inter_1_rejects.append("bbaabbbaaa") self.check_strings(inter_1, inter_1_accepts, inter_1_rejects) # Intersecção de DFA e NFA incompletos inter_2 = self.no_aaa.intersection(self.ends_in_aa) inter_2_accepts = ["aa", "baa", "abaa", "bbaa", "aabaa"] inter_2_rejects = list(set().union(self.no_aaa_reject, self.ends_in_aa_reject)) self.check_strings(inter_2, inter_2_accepts, inter_2_rejects) def test_difference(self): diff_1 = self.no_aaa.difference(self.ends_in_aa) diff_1_accepts = ["a", "", "aab", "aaba", "ba", "aba"] diff_1_rejects = list(set().union(self.no_aaa_reject, self.ends_in_aa_accept)) self.check_strings(diff_1, diff_1_accepts, diff_1_rejects) def test_remove_state(self): self.no_aaa.remove_state("B") self.assertTrue(self.no_aaa.transitions == \ self.no_aaa_removed_B) def test_remove_unreachable(self): reachable = copy.deepcopy(self.b_div_3.transitions) del reachable["D"] del reachable["H"] self.b_div_3.remove_unreachable() self.assertTrue(self.b_div_3.transitions == \ reachable) def test_remove_dead(self): alive = copy.deepcopy(self.no_aa) alive.remove_state("B") self.no_aa.remove_dead() self.assertTrue(self.no_aa.transitions == \ alive.transitions) def test_minimize(self): self.check_strings(self.b_div_3, self.b_div_3_accept, self.b_div_3_reject) self.b_div_3.minimize() self.check_strings(self.b_div_3, self.b_div_3_accept, self.b_div_3_reject)