def test_afw_to_nfa_conversion_language_bis(self):
""" Test a correct afw conversion to nfa comparing the language read
by the two automaton.
Here we take a nfa, we covert it to afw and back to nfa,
then the original and final nfa are compared trough the language
read.
"""
original_nfa_to_afw = AFW.nfa_to_afw_conversion(
self.nfa_afw_to_nfa_test_01)
nfa_01 = AFW.afw_to_nfa_conversion(original_nfa_to_afw)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
# print(word)
original_nfa_acceptance = NFA.nfa_word_acceptance(
self.nfa_afw_to_nfa_test_01, word)
nfa_acceptance = NFA.nfa_word_acceptance(nfa_01, word)
self.assertEqual(original_nfa_acceptance, nfa_acceptance)
i += 1
def test_word_acceptance_check_side_effects(self):
""" Tests that the function doesn't make any side effect on the
input"""
before = copy.deepcopy(self.afw_word_acceptance_test_01)
AFW.afw_word_acceptance(self.afw_word_acceptance_test_01,
['a', 'b', 'b', 'a', 'a', 'b', 'a', 'a'])
self.assertDictEqual(before, self.afw_word_acceptance_test_01)
def test_afw_completion_empty_transitions(self):
""" Tests a completion of a afw without transitions"""
self.afw_completion_test_01['transitions'] = {}
result = copy.deepcopy(self.afw_completion_test_01)
for state in result['states']:
for action in result['alphabet']:
result['transitions'][state, action] = 'False'
AFW.afw_completion(self.afw_completion_test_01)
self.assertDictEqual(self.afw_completion_test_01, result)
def test_afw_completion_empty_states(self):
""" Tests a completion of a afw without states"""
AFW.afw_completion(self.afw_completion_test_empty)
result = {
'alphabet': set(),
'states': set(),
'initial_state': None,
'accepting_states': set(),
'transitions': {}
}
self.assertDictEqual(self.afw_completion_test_empty, result)
def test_afw_completion(self):
""" Tests a correct afw completion comparing the language read,
that must be the same"""
original = copy.deepcopy(self.afw_completion_test_01)
AFW.afw_completion(self.afw_completion_test_01)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
original_acceptance = AFW.afw_word_acceptance(original, word)
completed_acceptance = AFW.afw_word_acceptance(
self.afw_completion_test_01, word)
self.assertEqual(original_acceptance, completed_acceptance)
i += 1
def test_afw_to_nfa_conversion_language_bis_bis(self):
""" Test a correct afw conversion to nfa comparing the language read
by the two automaton """
nfa_01 = AFW.afw_to_nfa_conversion(self.afw_nonemptiness_check_test_2)
# automata_IO.nfa_to_dot(nfa_01, 'afw_to_nfa_strange')
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
# print(word)
afw_acceptance = AFW.afw_word_acceptance(
self.afw_nonemptiness_check_test_2, word)
nfa_acceptance = NFA.nfa_word_acceptance(nfa_01, word)
self.assertEqual(afw_acceptance, nfa_acceptance)
i += 1
def test_nfa_to_afw_conversion_empty_states(self):
""" Tests converting an empty nfa """
expected_solution = {
'alphabet': set(),
'states': {'root'},
'initial_state': 'root',
'accepting_states': set(),
'transitions': {}
}
self.assertDictEqual(
AFW.nfa_to_afw_conversion(self.nfa_nfa_to_afw_test_empty),
expected_solution)
def test_afw_complementation(self):
""" Test a correct afw complementation comparing the language read,
that must be discording"""
afw_complemented = AFW.afw_complementation(
self.afw_complementation_test_01)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
afw_acceptance = AFW.afw_word_acceptance(
self.afw_complementation_test_01, word)
complement_acceptance = AFW.afw_word_acceptance(
afw_complemented, word)
self.assertNotEqual(afw_acceptance, complement_acceptance)
i += 1
def test_afw_complementation_empty_transitions(self):
""" Tests a complementation of a afw without transitions"""
self.afw_complementation_test_01['transitions'] = {}
result = copy.deepcopy(self.afw_complementation_test_01)
result['accepting_states'] = {'q1', 'q2'}
for state in result['states']:
for action in result['alphabet']:
result['transitions'][state, action] = 'True'
complemented = AFW.afw_complementation(
self.afw_complementation_test_01)
self.assertEqual(complemented, result)
def test_afw_intersection_equals(self):
""" Tests a correct afw intersection with the same afw """
AFW.rename_afw_states(self.afw_intersection_1_test_01, 'a_')
intersection = AFW.afw_intersection(self.afw_intersection_1_test_01,
self.afw_intersection_1_test_01)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
original_acceptance_1 = AFW.afw_word_acceptance(
self.afw_intersection_1_test_01, word)
original_acceptance_2 = AFW.afw_word_acceptance(
self.afw_intersection_1_test_01, word)
intersection_acceptance = AFW.afw_word_acceptance(intersection,
word)
self.assertEqual(
original_acceptance_1 and original_acceptance_2,
intersection_acceptance)
i += 1
def test_afw_union_intersecting(self):
""" Tests a correct afw union where the afws have some state in
common """
AFW.rename_afw_states(self.afw_union_3_test_01, 'a_')
union = AFW.afw_union(self.afw_union_1_test_01,
self.afw_union_3_test_01)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
# print(word)
original_acceptance_1 = AFW.afw_word_acceptance(
self.afw_union_1_test_01, word)
original_acceptance_2 = AFW.afw_word_acceptance(
self.afw_union_3_test_01, word)
union_acceptance = AFW.afw_word_acceptance(union, word)
self.assertEqual(
original_acceptance_1 or original_acceptance_2,
union_acceptance)
i += 1
def test_afw_union_empty_states_2(self):
""" Tests a afw union where the second afw is empty """
union = AFW.afw_union(self.afw_union_1_test_01,
self.afw_union_test_empty)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
original_acceptance_1 = AFW.afw_word_acceptance(
self.afw_union_1_test_01, word)
original_acceptance_2 = AFW.afw_word_acceptance(
self.afw_union_test_empty, word)
union_acceptance = AFW.afw_word_acceptance(union, word)
self.assertEqual(
original_acceptance_1 or original_acceptance_2,
union_acceptance)
i += 1
def test_nfa_to_afw_conversion_empty_transition(self):
""" Tests converting an nfa without transition """
expected_solution = {
'alphabet': self.nfa_nfa_to_afw_test_01['alphabet'],
'states': self.nfa_nfa_to_afw_test_01['states'].union({'root'}),
'initial_state': 'root',
'accepting_states': self.nfa_nfa_to_afw_test_01[
'accepting_states'],
'transitions': {}
}
self.nfa_nfa_to_afw_test_01['transitions'] = {}
self.assertDictEqual(
AFW.nfa_to_afw_conversion(self.nfa_nfa_to_afw_test_01),
expected_solution)
def test_nfa_to_afw_conversion(self):
""" Tests a correct nfa to afw conversion """
afw_01 = AFW.nfa_to_afw_conversion(self.nfa_nfa_to_afw_test_01)
self.assertSetEqual(afw_01['alphabet'],
self.afw_nfa_to_afw_test_01['alphabet'])
self.assertSetEqual(afw_01['states'],
self.afw_nfa_to_afw_test_01['states'])
self.assertEqual(afw_01['initial_state'],
self.afw_nfa_to_afw_test_01['initial_state'])
self.assertSetEqual(afw_01['accepting_states'],
self.afw_nfa_to_afw_test_01['accepting_states'])
self.assertEqual(len(afw_01['alphabet']),
len(self.afw_nfa_to_afw_test_01['alphabet']))
def test_afw_to_nfa_conversion_empty_transitions(self):
""" Tests a AFW to NFA conversion with a AFW without transitions """
self.afw_afw_to_nfa_test_01['transitions'] = {}
nfa_01 = AFW.afw_to_nfa_conversion(self.afw_afw_to_nfa_test_01)
result = {
'initial_states': {('s',)},
'accepting_states': {('s',)},
'transitions': {},
'states': {('s',)},
'alphabet': {'b', 'a'}
}
self.assertSetEqual(nfa_01['initial_states'], result['initial_states'])
self.assertDictEqual(nfa_01['transitions'], result['transitions'])
self.assertSetEqual(nfa_01['alphabet'], result['alphabet'])
self.assertEqual(len(nfa_01['accepting_states']),
len(result['accepting_states']))
self.assertEqual(len(nfa_01['states']), len(result['states']))
def test_afw_union_disjoint(self):
""" Tests a correct afw union with completely disjoint afws """
AFW.rename_afw_states(self.afw_union_2_test_01, 'a_')
union = AFW.afw_union(self.afw_union_1_test_01,
self.afw_union_2_test_01)
i = 0
last = 7
while i <= last:
base = list(itertools.repeat('a', i))
base += list(itertools.repeat('b', i))
# build all permutation of 'a' and 'b' till length i
word_set = set(itertools.permutations(base, i))
for word in word_set:
word = list(word)
original_acceptance_1 = AFW.afw_word_acceptance(
self.afw_union_1_test_01, word)
original_acceptance_2 = AFW.afw_word_acceptance(
self.afw_union_2_test_01, word)
union_acceptance = AFW.afw_word_acceptance(union, word)
self.assertEqual(
original_acceptance_1 or original_acceptance_2,
union_acceptance)
i += 1
def test_afw_intersection_wrong_dict_2(self):
""" Tests a dict() in input different from a well formatted dict()
representing a AFW. [EXPECTED FAILURE]"""
AFW.afw_intersection({'goofy': 'donald'},
self.afw_intersection_1_test_01)
def test_afw_nonuniversality_check_side_effects(self):
""" Tests that the function doesn't make any side effect on the
input"""
before = copy.deepcopy(self.afw_nonuniversality_check_test_1)
AFW.afw_nonuniversality_check(self.afw_nonuniversality_check_test_1)
self.assertDictEqual(before, self.afw_nonuniversality_check_test_1)
def test_afw_nonuniversality_check_wrong_input(self):
""" Tests the nonuniversality of an input different from a dict
object. [EXPECTED FAILURE] """
self.assertFalse(AFW.afw_nonuniversality_check(0))
def test_afw_nonuniversality_check_wrong_dict(self):
""" Tests the nonuniversality of an input dict different from a dict
representing a afw. [EXPECTED FAILURE] """
self.assertFalse(AFW.afw_nonuniversality_check({}))
def test_afw_nonuniversality_check_empty(self):
""" Tests the nonuniversality of an empty afw"""
self.assertFalse(AFW.afw_nonuniversality_check(
self.afw_nonuniversality_check_test_empty))
def test_afw_nonuniversality_check_false(self):
""" Tests a correct afw nonuniversality check, where the afw is
empty """
self.assertFalse(AFW.afw_nonuniversality_check(
self.afw_nonuniversality_check_test_2))
def test_afw_nonuniversality_check(self):
""" Tests a correct afw nonuniversality check """
self.assertTrue(AFW.afw_nonuniversality_check(
self.afw_nonuniversality_check_test_1))
def test_afw_nonemptiness_check_empty(self):
""" Tests the nonemptiness of an empty afw"""
self.assertFalse(
AFW.afw_nonemptiness_check(self.afw_nonemptiness_check_test_empty))
def test_afw_nonemptiness_check_false(self):
""" Tests a correct afw nonemptiness check, where the afw is empty """
self.assertFalse(
AFW.afw_nonemptiness_check(self.afw_nonemptiness_check_test_2))
def test_afw_nonemptiness_check(self):
""" Tests a correct afw nonemptiness check """
self.assertTrue(
AFW.afw_nonemptiness_check(self.afw_nonemptiness_check_test_1))
def test_afw_intersection_side_effects_2(self):
""" Tests the function makes side effect on the second input """
before = copy.deepcopy(self.afw_intersection_2_test_01)
AFW.afw_intersection(self.afw_intersection_1_test_01,
self.afw_intersection_2_test_01)
self.assertEqual(before, self.afw_intersection_2_test_01)
def test_afw_intersection_wrong_input_2(self):
""" Tests an input different from a dict() object. [EXPECTED
FAILURE]"""
AFW.afw_intersection(self.afw_intersection_1_test_01, 0)
def test_afw_union_wrong_input_1(self):
""" Tests an input different from a dict() object. [EXPECTED
FAILURE]"""
AFW.afw_union(0, self.afw_union_1_test_01)
def test_word_acceptance_wrong_dict(self):
""" Tests a dict() in input different from a well formatted dict()
representing a AFW. [EXPECTED FAILURE]"""
AFW.afw_word_acceptance({'goofy': 'donald'}, ['a', 'b', 'b', 'a', 'b'])