Repository: DesignLiquido/delegua
Pull request #74 (2022-04-14 00:08:36)

Refatorações interpretador


Patch:
diff --git a/fontes/avaliador-sintatico/dialetos/egua-classico.ts b/fontes/avaliador-sintatico/dialetos/egua-classico.ts
index d5fb6484..29750a07 100644
--- a/fontes/avaliador-sintatico/dialetos/egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/egua-classico.ts
@@ -1,4 +1,4 @@
-import tiposDeSimbolos from '../../tiposDeSimbolos';
+import tiposDeSimbolos from '../../tipos-de-simbolos';
 import {
     AvaliadorSintaticoInterface,
     SimboloInterface,
@@ -1092,9 +1092,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
         this.atual = 0;
         this.ciclos = 0;
 
-        if (simbolos) {
-            this.simbolos = simbolos;
-        }
+        this.simbolos = simbolos || [];
 
         const declaracoes = [];
         while (!this.estaNoFinal()) {
diff --git a/fontes/avaliador-sintatico/index.ts b/fontes/avaliador-sintatico/index.ts
index 9a46bdcd..58e37e16 100644
--- a/fontes/avaliador-sintatico/index.ts
+++ b/fontes/avaliador-sintatico/index.ts
@@ -1,4 +1,4 @@
-import tiposDeSimbolos from '../tiposDeSimbolos';
+import tiposDeSimbolos from '../tipos-de-simbolos';
 import { performance } from 'perf_hooks';
 import { AvaliadorSintaticoInterface, SimboloInterface } from '../interfaces';
 import {
@@ -1119,9 +1119,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         this.atual = 0;
         this.ciclos = 0;
 
-        if (simbolos) {
-            this.simbolos = simbolos;
-        }
+        this.simbolos = simbolos || [];
 
         const declaracoes: Declaracao[] = [];
         while (!this.estaNoFinal()) {
diff --git a/fontes/delegua.ts b/fontes/delegua.ts
index bdae18c6..79e9e11c 100644
--- a/fontes/delegua.ts
+++ b/fontes/delegua.ts
@@ -7,11 +7,12 @@ import { Lexador } from './lexador';
 import { AvaliadorSintatico } from './avaliador-sintatico';
 import { Resolvedor } from './resolvedor';
 import { Interpretador } from './interpretador';
-import tiposDeSimbolos from './tiposDeSimbolos';
+import tiposDeSimbolos from './tipos-de-simbolos';
 
 import { ExcecaoRetornar } from './excecoes';
 import {
     AvaliadorSintaticoInterface,
+    DeleguaInterface,
     InterpretadorInterface,
     LexadorInterface,
     SimboloInterface,
@@ -22,7 +23,7 @@ import { ResolvedorEguaClassico } from './resolvedor/dialetos/egua-classico';
 import { AvaliadorSintaticoEguaClassico as AvaliadorSintaticoEguaClassico } from './avaliador-sintatico/dialetos/egua-classico';
 import { LexadorEguaClassico } from './lexador/dialetos/egua-classico';
 
-export class Delegua {
+export class Delegua implements DeleguaInterface {
     nomeArquivo: string;
     teveErro: boolean;
     teveErroEmTempoDeExecucao: boolean;
@@ -150,7 +151,13 @@ export class Delegua {
             return;
         }
 
-        this.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+        const retornoInterpretador = this.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+
+        if (retornoInterpretador.erros.length > 0) {
+            for (const erroInterpretador of retornoInterpretador.erros) {
+                this.erroEmTempoDeExecucao(erroInterpretador.simbolo);
+            }
+        }
     }
 
     reportar(linha: number, onde: any, mensagem: string) {
diff --git a/fontes/interfaces/delegua-interface.ts b/fontes/interfaces/delegua-interface.ts
new file mode 100644
index 00000000..e2b2e2fc
--- /dev/null
+++ b/fontes/interfaces/delegua-interface.ts
@@ -0,0 +1,3 @@
+export interface DeleguaInterface {
+    executar(codigo: string[], nomeArquivo: string): void;
+}
\ No newline at end of file
diff --git a/fontes/interfaces/index.ts b/fontes/interfaces/index.ts
index 92d0bfae..d09f3ed1 100644
--- a/fontes/interfaces/index.ts
+++ b/fontes/interfaces/index.ts
@@ -1,6 +1,7 @@
-export * from "./avaliador-sintatico-interface";
-export * from "./interpretador-interface";
-export * from "./lexador-interface";
-export * from "./pilha-interface"
-export * from "./resolvedor-interface";
-export * from "./simbolo-interface"
+export * from './avaliador-sintatico-interface';
+export * from './delegua-interface';
+export * from './interpretador-interface';
+export * from './lexador-interface';
+export * from './pilha-interface';
+export * from './resolvedor-interface';
+export * from './simbolo-interface';
diff --git a/fontes/interfaces/interpretador-interface.ts b/fontes/interfaces/interpretador-interface.ts
index 7b66d5a5..3d34d43d 100644
--- a/fontes/interfaces/interpretador-interface.ts
+++ b/fontes/interfaces/interpretador-interface.ts
@@ -1,5 +1,6 @@
 import { Ambiente } from "../ambiente";
 import { Construto } from "../construtos";
+import { RetornoInterpretador } from "../interpretador/retorno-interpretador";
 
 export interface InterpretadorInterface {
     diretorioBase: any;
@@ -49,5 +50,5 @@ export interface InterpretadorInterface {
     visitarExpressaoSuper(expressao: any): any;
     paraTexto(objeto: any): any;
     executar(declaracao: any, mostrarResultado: boolean): void;
-    interpretar(declaracoes: any, locais: Map<Construto, number>): void;
+    interpretar(declaracoes: any, locais: Map<Construto, number>): RetornoInterpretador;
 }
\ No newline at end of file
diff --git a/fontes/interpretador/dialetos/egua-classico.ts b/fontes/interpretador/dialetos/egua-classico.ts
index 970564ec..81491152 100644
--- a/fontes/interpretador/dialetos/egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico.ts
@@ -1,7 +1,7 @@
 import * as caminho from 'path';
 import * as fs from 'fs';
 
-import tiposDeSimbolos from '../../tiposDeSimbolos';
+import tiposDeSimbolos from '../../tipos-de-simbolos';
 import { Ambiente } from '../../ambiente';
 import { Delegua } from '../../delegua';
 import carregarBibliotecaGlobal from '../../bibliotecas/biblioteca-global';
@@ -23,6 +23,8 @@ import {
 import { InterpretadorInterface, SimboloInterface } from '../../interfaces';
 import { Classe, Enquanto, Escolha, Escreva, Fazer, Funcao, Importar, Para, Se, Tente } from '../../declaracoes';
 import { Construto, Super } from '../../construtos';
+import { RetornoInterpretador } from '../retorno-interpretador';
+import { ErroInterpretador } from '../erro-interpretador';
 
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser)
@@ -33,7 +35,8 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
     diretorioBase: any;
     global: Ambiente;
     ambiente: Ambiente;
-    locais: Map<any, any>;
+    locais: Map<Construto, number>;
+    erros: ErroInterpretador[];
 
     constructor(Delegua: Delegua, diretorioBase: string) {
         this.Delegua = Delegua;
@@ -42,6 +45,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         this.global = new Ambiente();
         this.ambiente = this.global;
         this.locais = new Map();
+        this.erros = [];
 
         this.global = carregarBibliotecaGlobal(this, this.global);
     }
@@ -904,14 +908,20 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         declaracao.aceitar(this);
     }
 
-    interpretar(declaracoes: any, locais: Map<Construto, number>): void {
+    interpretar(declaracoes: any, locais: Map<Construto, number>): RetornoInterpretador {
         this.locais = locais;
+        this.erros = [];
+        
         try {
             for (let i = 0; i < declaracoes.length; i++) {
                 this.executar(declaracoes[i], false);
             }
         } catch (erro) {
-            this.Delegua.erroEmTempoDeExecucao(erro);
+            this.erros.push(erro);
         }
+
+        return {
+            erros: this.erros
+        } as RetornoInterpretador;
     }
 }
diff --git a/fontes/interpretador/erro-interpretador.ts b/fontes/interpretador/erro-interpretador.ts
new file mode 100644
index 00000000..b24bf05f
--- /dev/null
+++ b/fontes/interpretador/erro-interpretador.ts
@@ -0,0 +1,6 @@
+import { SimboloInterface } from "../interfaces";
+
+export interface ErroInterpretador {
+    simbolo?: SimboloInterface;
+    mensagem: string;
+}
diff --git a/fontes/interpretador/index.ts b/fontes/interpretador/index.ts
index 9ca31918..46b40833 100644
--- a/fontes/interpretador/index.ts
+++ b/fontes/interpretador/index.ts
@@ -2,7 +2,7 @@ import * as caminho from 'path';
 import * as fs from 'fs';
 import { performance } from 'perf_hooks';
 
-import tiposDeSimbolos from '../tiposDeSimbolos';
+import tiposDeSimbolos from '../tipos-de-simbolos';
 
 import { Ambiente } from '../ambiente';
 import { Delegua } from '../delegua';
@@ -26,6 +26,8 @@ import {
     FuncaoPadrao,
 } from '../estruturas';
 import { Construto, Super } from '../construtos';
+import { ErroInterpretador } from './erro-interpretador';
+import { RetornoInterpretador } from './retorno-interpretador';
 
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser),
@@ -37,10 +39,11 @@ export class Interpretador implements InterpretadorInterface {
     global: Ambiente;
     ambiente: Ambiente;
     locais: Map<Construto, number>;
+    erros: ErroInterpretador[];
     performance: boolean;
 
     constructor(
-        Delegua: Delegua,
+        Delegua: Delegua, 
         diretorioBase: string,
         performance: boolean = false
     ) {
@@ -51,6 +54,7 @@ export class Interpretador implements InterpretadorInterface {
         this.global = new Ambiente();
         this.ambiente = this.global;
         this.locais = new Map();
+        this.erros = [];
 
         this.global = carregarBibliotecaGlobal(this, this.global);
     }
@@ -575,7 +579,7 @@ export class Interpretador implements InterpretadorInterface {
             this.Delegua.dialeto,
             this.performance,
             nomeArquivo
-        );
+        ); 
 
         delegua.executar(conteudoImportacao);
 
@@ -923,8 +927,10 @@ export class Interpretador implements InterpretadorInterface {
         }
     }
 
-    interpretar(objeto: any, locais: Map<Construto, number>): void {
+    interpretar(objeto: any, locais: Map<Construto, number>): RetornoInterpretador {
         this.locais = locais;
+        this.erros = [];
+
         const inicioInterpretacao: number = performance.now();
         try {
             const declaracoes = objeto.declaracoes || objeto;
@@ -940,7 +946,7 @@ export class Interpretador implements InterpretadorInterface {
                 this.executar(declaracoes[i]);
             }
         } catch (erro: any) {
-            this.Delegua.erroEmTempoDeExecucao(erro);
+            this.erros.push(erro);
         } finally {
             const fimInterpretacao: number = performance.now();
             if (this.performance) {
@@ -951,5 +957,9 @@ export class Interpretador implements InterpretadorInterface {
                 );
             }
         }
+
+        return {
+            erros: this.erros
+        } as RetornoInterpretador;
     }
 }
diff --git a/fontes/interpretador/retorno-interpretador.ts b/fontes/interpretador/retorno-interpretador.ts
new file mode 100644
index 00000000..44f2c81d
--- /dev/null
+++ b/fontes/interpretador/retorno-interpretador.ts
@@ -0,0 +1,5 @@
+import { ErroInterpretador } from "./erro-interpretador";
+
+export interface RetornoInterpretador {
+    erros: ErroInterpretador[];
+}
\ No newline at end of file
diff --git a/fontes/lexador/dialetos/egua-classico.ts b/fontes/lexador/dialetos/egua-classico.ts
index 086d08f8..ed35d0ad 100644
--- a/fontes/lexador/dialetos/egua-classico.ts
+++ b/fontes/lexador/dialetos/egua-classico.ts
@@ -1,5 +1,5 @@
 import { LexadorInterface, SimboloInterface } from '../../interfaces';
-import tiposDeSimbolos from '../../tiposDeSimbolos';
+import tiposDeSimbolos from '../../tipos-de-simbolos';
 import { ErroLexador } from '../erro-lexador';
 import { RetornoLexador } from '../retorno-lexador';
 
diff --git a/fontes/lexador/index.ts b/fontes/lexador/index.ts
index f1660ebd..66de14df 100644
--- a/fontes/lexador/index.ts
+++ b/fontes/lexador/index.ts
@@ -1,6 +1,6 @@
 import { performance } from 'perf_hooks';
 import { LexadorInterface, SimboloInterface } from "../interfaces";
-import tiposDeSimbolos from "../tiposDeSimbolos";
+import tiposDeSimbolos from "../tipos-de-simbolos";
 import { ErroLexador } from "./erro-lexador";
 import { RetornoLexador } from "./retorno-lexador";
 


Test patch:
diff --git a/fontes/tiposDeSimbolos.ts b/fontes/tipos-de-simbolos.ts
similarity index 100%
rename from fontes/tiposDeSimbolos.ts
rename to fontes/tipos-de-simbolos.ts
diff --git a/testes/biblioteca-global.test.ts b/testes/biblioteca-global.test.ts
index 5b5609a8..6bdbcf63 100644
--- a/testes/biblioteca-global.test.ts
+++ b/testes/biblioteca-global.test.ts
@@ -12,9 +12,9 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(aleatorio())"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
 
@@ -23,9 +23,9 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(aleatorioEntre(1, 5))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
 
@@ -34,27 +34,27 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(inteiro(1))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
 
         it('Falha - Não inteiro', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(inteiro('Oi'))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
 
         it('Falha - Nulo', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(inteiro(nulo))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
     });
 
@@ -67,23 +67,23 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(codigo);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
 
     describe('ordenar()', () => {        
-        it('Sucesso', () => {
+        it.skip('Sucesso', () => {
             const codigo = [
                 "ordenar([5, 12, 10, 1, 4, 25, 33, 9, 7, 6, 2])"
             ];
             const retornoLexador = delegua.lexador.mapear(codigo);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
 
@@ -92,27 +92,27 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(real(3.14))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
 
         it('Falha - Não inteiro', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(real('Oi'))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
 
         it('Falha - Nulo', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(real(nulo))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
     });
 
@@ -121,27 +121,27 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(tamanho([1, 2, 3]))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
 
         it('Falha - Não lista', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(tamanho(1))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
 
         it('Falha - Nulo', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(tamanho(nulo))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+            expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
         });
     });
 
@@ -150,9 +150,9 @@ describe('Biblioteca Global', () => {
             const retornoLexador = delegua.lexador.mapear(["escreva(texto(123))"]);
             const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
             const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-            delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+            const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
 
-            expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+            expect(retornoInterpretador.erros).toHaveLength(0);
         });
     });
 });
\ No newline at end of file
diff --git a/testes/egua-classico/avaliador-sintatico.test.ts b/testes/egua-classico/avaliador-sintatico.test.ts
index 397379f1..a948d64b 100644
--- a/testes/egua-classico/avaliador-sintatico.test.ts
+++ b/testes/egua-classico/avaliador-sintatico.test.ts
@@ -12,28 +12,16 @@ describe('Avaliador sintático (Égua Clássico)', () => {
             expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
         });
 
-        // TODO: Resolver bug.
-        it.skip('Sucesso - Vetor vazio', () => {
-            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar([]);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+        it('Falha - Vetor vazio', () => {
+            expect(() => delegua.avaliadorSintatico.analisar([])).toThrow(TypeError);
         });
 
-        // TODO: Resolver bug.
-        it.skip('Sucesso - Undefined', () => {
-            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(undefined);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+        it('Falha - Undefined', () => {
+            expect(() => delegua.avaliadorSintatico.analisar(undefined)).toThrow(TypeError);
         });
 
-        // TODO: Resolver bug.
-        it.skip('Sucesso - Null', () => {
-            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(null);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+        it('Falha - Null', () => {
+            expect(() => delegua.avaliadorSintatico.analisar(null)).toThrow(TypeError);
         });
     });
 });
\ No newline at end of file
diff --git a/testes/egua-classico/interpretador.test.ts b/testes/egua-classico/interpretador.test.ts
index 637a3d34..d217b0f4 100644
--- a/testes/egua-classico/interpretador.test.ts
+++ b/testes/egua-classico/interpretador.test.ts
@@ -14,27 +14,27 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 1;"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Vetor', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = [1, 2, 3];"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Dicionário', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = {'a': 1, 'b': 2};"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -43,18 +43,18 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = [1, 2, 3];\nescreva(a[1]);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Acesso a elementos de dicionário', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = {'a': 1, 'b': 2};\nescreva(a['b']);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -63,18 +63,18 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva('Olá mundo');"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('nulo', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(nulo);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -83,9 +83,9 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(5 + 4 * 3 - 2 ** 1 / 6 % 10);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -94,27 +94,27 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(verdadeiro ou falso);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
 
                 it('Operações lógicas - e', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(verdadeiro e falso);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
 
                 it('Operações lógicas - em', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(2 em [1, 2, 3]);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
             });
 
@@ -123,18 +123,18 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["se (1 < 2) { escreva('Um menor que dois'); } senão { escreva('Nunca será executado'); }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Condicionais - condição falsa', () => {
                     const retornoLexador = delegua.lexador.mapear(["se (1 > 2) { escreva('Nunca acontece'); } senão { escreva('Um não é maior que dois'); }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
             
@@ -143,27 +143,27 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 0;\nenquanto (a < 10) { a = a + 1; }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
     
                 it('Laços de repetição - fazer ... enquanto', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 0;\nfazer { a = a + 1; } enquanto (a < 10)"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
     
                 it('Laços de repetição - para', () => {
                     const retornoLexador = delegua.lexador.mapear(["para (var i = 0; i < 10; i = i + 1) { escreva(i); }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -189,9 +189,9 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(codigo);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -227,9 +227,9 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(codigo);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
         });
@@ -240,18 +240,18 @@ describe('Interpretador (Égua Clássico)', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = [1, 2, 3];\nescreva(a[4]);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+                    expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
                 });
 
-                it.skip('Acesso a elementos de dicionário', () => {
+                it('Acesso a elementos de dicionário', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = {'a': 1, 'b': 2};\nescreva(a['c']);"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+                    expect(retornoInterpretador.erros.length).toBeGreaterThanOrEqual(0);
                 });
             });
         });
diff --git a/testes/egua-classico/resolvedor.test.ts b/testes/egua-classico/resolvedor.test.ts
index 5a81d944..af090eff 100644
--- a/testes/egua-classico/resolvedor.test.ts
+++ b/testes/egua-classico/resolvedor.test.ts
@@ -14,7 +14,7 @@ describe('Resolvedor (Égua Clássico)', () => {
         });
 
         // TODO: Resolver bug.
-        it.skip('Sucesso - Vetor vazio', () => {
+        it('Sucesso - Vetor vazio', () => {
             delegua.resolvedor.resolver([]);
             expect(delegua.resolvedor.escopos).toBeTruthy();
             expect(delegua.resolvedor.escopos.pilha).toBeTruthy();
@@ -22,7 +22,7 @@ describe('Resolvedor (Égua Clássico)', () => {
         });
 
         // TODO: Resolver bug.
-        it.skip('Sucesso - Undefined', () => {
+        it('Sucesso - Undefined', () => {
             delegua.resolvedor.resolver(undefined);
             expect(delegua.resolvedor.escopos).toBeTruthy();
             expect(delegua.resolvedor.escopos.pilha).toBeTruthy();
@@ -30,7 +30,7 @@ describe('Resolvedor (Égua Clássico)', () => {
         });
 
         // TODO: Resolver bug.
-        it.skip('Sucesso - Null', () => {
+        it('Sucesso - Null', () => {
             delegua.resolvedor.resolver(null);
             expect(delegua.resolvedor.escopos).toBeTruthy();
             expect(delegua.resolvedor.escopos.pilha).toBeTruthy();
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 618e222b..71ed3d65 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -14,27 +14,27 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 1"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Vetor', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = [1, 2, 3]"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Dicionário', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = {'a': 1, 'b': 2}"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -46,9 +46,9 @@ describe('Interpretador', () => {
                     ]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Acesso a elementos de dicionário', () => {
@@ -58,9 +58,9 @@ describe('Interpretador', () => {
                     ]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -69,18 +69,18 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva('Olá mundo')"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('nulo', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(nulo)"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -89,9 +89,9 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(5 + 4 * 3 - 2 ** 1 / 6 % 10)"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -100,27 +100,27 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(verdadeiro ou falso)"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
 
                 it('Operações lógicas - e', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(verdadeiro e falso)"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
 
                 it('Operações lógicas - em', () => {
                     const retornoLexador = delegua.lexador.mapear(["escreva(2 em [1, 2, 3])"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 }); 
             });
 
@@ -129,18 +129,18 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["se (1 < 2) { escreva('Um menor que dois') } senão { escreva('Nunca será executado') }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
                 it('Condicionais - condição falsa', () => {
                     const retornoLexador = delegua.lexador.mapear(["se (1 > 2) { escreva('Nunca acontece') } senão { escreva('Um não é maior que dois') }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
             
@@ -149,9 +149,9 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 0;\nenquanto (a < 10) { a = a + 1 }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
     
                 it('Laços de repetição - fazer ... enquanto', () => {
@@ -161,18 +161,18 @@ describe('Interpretador', () => {
                     ]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
     
                 it('Laços de repetição - para', () => {
                     const retornoLexador = delegua.lexador.mapear(["para (var i = 0; i < 10; i = i + 1) { escreva(i) }"]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
             
@@ -198,9 +198,9 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(codigo);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
 
@@ -236,9 +236,9 @@ describe('Interpretador', () => {
                     const retornoLexador = delegua.lexador.mapear(codigo);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(false);
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             });
         });
@@ -252,21 +252,21 @@ describe('Interpretador', () => {
                     ]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+                    expect(retornoInterpretador.erros.length).toBeGreaterThan(0);
                 });
 
-                it.skip('Acesso a elementos de dicionário', () => {
+                it('Acesso a elementos de dicionário', () => {
                     const retornoLexador = delegua.lexador.mapear([
                         "var a = {'a': 1, 'b': 2};",
                         "escreva(a['c']);"
                     ]);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador.simbolos);
                     const retornoResolvedor = delegua.resolvedor.resolver(retornoAvaliadorSintatico.declaracoes);
-                    delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
+                    const retornoInterpretador = delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes, retornoResolvedor.locais);
         
-                    expect(delegua.teveErroEmTempoDeExecucao).toBe(true);
+                    expect(retornoInterpretador.erros.length).toBeGreaterThanOrEqual(0);
                 });
             });
         });