def do_test(self, path, minp, maxp, expected):
'''Implementazione del test
- path : cartella da cui iniziare la ricerca
- minp : dimensione minima del file
- maxp : dimensione massima del file
- expected : dizionario atteso
'''
try:
isrecursive.decorate_module(program)
program.es71(path, minp, maxp)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es71(path, minp, maxp)
self.assertEqual(type(result), dict,
"Il risultato non è un dizionario")
self.assertEqual(
result, expected, f"Il risultato deve essere {expected} invece che {result}")
def do_test(self, filename, expected):
'''Implementazione del test
- ftesto: il file in cui reperire la matrice e la lista delle parole
- expected: la lista attesa
'''
expected = [ x if x==-1 else tuple(x) for x in expected ]
if DEBUG:
import program01 as program
result = program.es1(filename)
else:
# prima controlliamo che l'implementazione sia ricorsiva
try:
import program01 as program
isrecursive.decorate_module(program)
program.es1(filename)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
del program
with self.ignored_function('builtins.print'), \
self.ignored_function('pprint.pprint'), \
self.forbidden_function('builtins.input'), \
self.check_open({filename : ['r']}), \
self.check_imports( allowed=['program01','encodings.utf_8','encodings.utf_8_sig']), \
self.timeout(1), \
self.timer(1):
import program01 as program
result = program.es1(filename)
self.assertIsInstance(result, list, "il risultato prodotto non e' una lista")
self.assertEqual(result, expected, "la lista restituita non e' corretta")
def do_test(self, path, ext, par, expected):
'''Implementazione del test
- path : path della directory da cui partire con la ricerca
- ext : estensioni dei file da non cercare
- par : lista di parole da cercare
- expected : dizionario atteso
'''
try:
isrecursive.decorate_module(program)
program.es70(path, ext, par)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es70(path, ext, par)
self.assertEqual(type(result), dict,
"Il risultato non è un dizionario")
self.assertEqual(
result, expected,
f"Il risultato deve essere {expected} invece che {result}")
def do_test(self, lista1, lista2, expected):
'''Implementazione del test:
- lista1: lista nodi albero 1 in input
- lista2: lista nodi albero 2 in input
- expected: lista nodi albero output
'''
#controllo la ricorsione
tree1 = albero.AlberoBinario.fromList(lista1)
tree2 = albero.AlberoBinario.fromList(lista2)
try:
isrecursive.decorate_module(program)
program.es1(tree1, tree2)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.ignored_function('pprint.pprint'), \
self.timer(3):
result = program.es1(tree1, tree2)
self.assertEqual(lista1, tree1.toList(), "tree1 è stato modificato")
self.assertEqual(lista2, tree2.toList(), "tree2 è stato modificato")
self.assertEqual(result.toList(), expected,
"L'albero tree3 restituito non e' corretto")
def decorated(self, module):
'''Return a 'with' context decorating all functions/methods to raise RecursionDetectedError if recursive.'''
import isrecursive
isrecursive.decorate_module(module)
try:
yield module
finally:
isrecursive.undecorate_module(module)
def do_test(self, path, expected):
try:
isrecursive.decorate_module(program)
program.es9(path)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.ignored_function('pprint.pprint'), \
self.timer(3):
result = program.es9(path)
self.assertEqual(type(result), list, "Bisogna restituire una lista")
self.assertEqual(result, expected, "La risposta non e' corretta")
def do_test(self, lista, ins, k, expected):
tree = albero.fromLista(lista)
try:
isrecursive.decorate_module(program)
program.es7(tree, ins, k)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
tree = albero.fromLista(lista)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es7(tree, ins, k)
self.assertEqual(result, expected,
"il valore restituito non e' corretto")
def do_test(self, parola, expected):
'''Implementazione del test
- parola : stringa di caratteri
- expected : lista dei suffissi attesa
'''
par2 = copy.deepcopy(parola)
try:
isrecursive.decorate_module(program)
program.es77(par2)
except isrecursive.RecursionDetectedError:
raise Exception("Recursion detected.")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es77(parola)
self.assertEqual(type(result), list, "Il risultato non è una lista")
self.assertEqual(
result, expected,
f"Il risultato deve essere {expected} invece che {result}")
def do_test(self, livello, expected):
'''Implementazione del test
- livello : livello dell'albero
- expected : albero atteso
'''
try:
isrecursive.decorate_module(program)
program.es1(livello)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(3):
result = program.es1(livello)
self.assertEqual(
albero.toLista(result), expected,
f"Il risultato deve essere {expected} invece che {result}, input k={livello}"
)
def do_test(self, path, prof, lst, expected, present, absent):
'''Implementazione del test
- path : directory da cui iniziare la ricerca
- prof : profondità a cui eliminare i file
- lst : lista delle estensioni
- expected : numero di file atteso
- present : path dei file da non cancellare
- absent : path dei file da cancellare
'''
dir2 = path + "Copy"
shutil.rmtree(dir2, ignore_errors=True)
shutil.copytree(path, dir2)
try:
isrecursive.decorate_module(program)
program.es69(dir2, prof, lst)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
shutil.rmtree(dir2, ignore_errors=True)
shutil.copytree(path, dir2)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es69(dir2, prof, lst)
self.assertEqual(type(result), int, "Il risultato non è un intero")
self.assertEqual(
result, expected,
f"Il risultato deve essere {expected} invece che {result}")
for f in present:
self.assertTrue(os.path.exists(f),
f"Non dovevi eliminare il file {f}")
for f in absent:
self.assertFalse(os.path.exists(f),
f"Dovevi eliminare il file {f}")
def do_test(self, tree, expected):
'''Implementazione del test
- tree : albero binario sotto forma di lista
- expected : numero di nodi atteso
'''
tree1 = albero.AlberoBinario.fromList(tree)
tree2 = copy.deepcopy(tree1)
try:
isrecursive.decorate_module(program)
program.es48(tree2)
except isrecursive.RecursionDetectedError:
pass
else:
raise Exception("Recursion not present")
finally:
isrecursive.undecorate_module(program)
with self.ignored_function('builtins.print'), \
self.forbidden_function('os.walk'), \
self.timer(2):
result = program.es48(tree1)
self.assertEqual(
result, expected,
f"Il risultato deve essere {expected} invece che {result}")