Ejemplo n.º 1
0
    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")
Ejemplo n.º 3
0
    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}")
Ejemplo n.º 4
0
    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")
Ejemplo n.º 5
0
 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)
Ejemplo n.º 6
0
    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")
Ejemplo n.º 7
0
 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")
Ejemplo n.º 8
0
    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}")
Ejemplo n.º 9
0
    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}"
        )
Ejemplo n.º 10
0
 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}")
Ejemplo n.º 11
0
    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}")