Repository: DesignLiquido/delegua
Pull request #224 (2023-01-05 23:56:09)

#202 Testes tradução reversa e melhorias
Resolve:
- https://github.com/DesignLiquido/delegua/issues/196
- https://github.com/DesignLiquido/delegua/issues/198

github-actions[bot]: <!-- jest coverage report action for options with hash 825fd481788efa7282e8569b20438413 -->

## Coverage report 



| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | Category   | Percentage                                                     | Covered / Total |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :--------- | :------------------------------------------------------------- | :-------------: |
|                                                                           🟡                                                                           | Statements | <div title="Base coverage is: 68.69%">68.72% (+0.03% 🔼)</div> |    3507/5103    |
|                                                                           🔴                                                                           | Branches   | <div title="Base coverage is: 57.4%">57.5% (+0.1% 🔼)</div>    |    1024/1781    |
|                                                                           🟡                                                                           | Functions  | <div title="Base coverage is: 66.71%">66.8% (+0.09% 🔼)</div>  |     501/750     |
|                                                                           🟡                                                                           | Lines      | <div title="Base coverage is: 68.92%">68.96% (+0.03% 🔼)</div> |    3394/4922    |


## Test suite run success
215 tests passing in 19 suites.

<p align="right">Report generated by <a href="https://github.com/ArtiomTr/jest-coverage-report-action">🧪jest coverage report action</a> from c07251b65df47ecb6b82fd1cfe9d34c41b2b3955</p>
<!-- Sticky Pull Request Comment -->

Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index c8d151fe..22525063 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -329,6 +329,34 @@
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen"
         },
+        {
+            "name": "Testes unitários - Tradutor Delégua para Javascript",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                "tradutor-javascript.test.ts",
+                "--runInBand"
+            ],
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
+        },
+        {
+            "name": "Testes unitários - Tradutor Javascript para Delégua",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                "tradutor-reverso-javascript.test.ts",
+                "--runInBand"
+            ],
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
+        },
         {
             "type": "node",
             "request": "launch",
@@ -657,7 +685,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Tradutores > Delégua => JavaScript > Teste",
+            "name": "Tradutores > Delégua > JavaScript > Teste",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -666,7 +694,7 @@
                 "-t",
                 "js",
                 "-s",
-                "./testes/exemplos/condicionais/se.egua"
+                "./testes/exemplos/condicionais/se.delegua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
diff --git a/fontes/delegua.ts b/fontes/delegua.ts
index f7f8c82c..b0fb9279 100644
--- a/fontes/delegua.ts
+++ b/fontes/delegua.ts
@@ -33,7 +33,7 @@ import { LexadorVisuAlg } from './lexador/dialetos/lexador-visualg';
 import { AvaliadorSintaticoVisuAlg } from './avaliador-sintatico/dialetos/avaliador-sintatico-visualg';
 import { LexadorBirl } from './lexador/dialetos/lexador-birl';
 import { AvaliadorSintaticoBirl } from './avaliador-sintatico/dialetos/avaliador-sintatico-birl';
-import { TradutorJavaScript } from './tradutores/tradutor-javascript';
+import { TradutorJavaScript, TradutorReversoJavaScript } from './tradutores';
 import { InterpretadorVisuAlg } from './interpretador/dialetos/visualg';
 
 /**
@@ -58,14 +58,15 @@ export class Delegua implements DeleguaInterface {
     lexador: LexadorInterface;
     avaliadorSintatico: AvaliadorSintaticoInterface;
     importador: ImportadorInterface;
-    tradutor: TradutorJavaScript;
+    tradutorJavaScript: TradutorJavaScript;
+    tradutorReversoJavascript: TradutorReversoJavaScript;
 
     funcaoDeRetorno: Function;
     modoDepuracao: boolean;
 
     servidorDepuracao: ServidorDepuracao;
 
-    constructor(dialeto = 'delegua', performance = false, depurador = false, traduzir = null, funcaoDeRetorno: Function = null) {
+    constructor(dialeto = 'delegua', performance = false, depurador = false, traduzir: any = null, funcaoDeRetorno: Function = null) {
         this.arquivosAbertos = {};
         this.conteudoArquivosAbertos = {};
 
@@ -144,8 +145,18 @@ export class Delegua implements DeleguaInterface {
                 break;
         }
 
-        if (traduzir !== null && traduzir !== undefined) {
-            this.tradutor = new TradutorJavaScript();
+        if (traduzir) {
+            switch(traduzir){
+                case 'javascript':
+                case 'js':
+                    this.tradutorJavaScript = new TradutorJavaScript();
+                    break;
+                case 'delegua':
+                    this.tradutorReversoJavascript = new TradutorReversoJavaScript();
+                    break;
+                default:
+                    throw new Error(`Tradutor '${traduzir}' não implementado.`)
+            }                
         }
 
         if (depurador) {
@@ -268,13 +279,18 @@ export class Delegua implements DeleguaInterface {
 
         this.importador.diretorioBase = novoDiretorioBase;
 
-        const retornoImportador = this.importador.importar(caminhoRelativoArquivo, true);
+        const retornoImportador = this.importador.importar(caminhoRelativoArquivo, true, !!this.tradutorReversoJavascript);
 
-        if (this.afericaoErros(retornoImportador)) {
-            process.exit(65); // Código para erro de avaliação antes da tradução
+        let resultado = null;
+        if(!!this.tradutorJavaScript){
+            if (this.afericaoErros(retornoImportador)) {
+                process.exit(65); // Código para erro de avaliação antes da tradução
+            }
+            resultado = this.tradutorJavaScript.traduzir(retornoImportador.retornoAvaliadorSintatico.declaracoes);
+        }
+        else{
+            resultado = this.tradutorReversoJavascript.traduzir(retornoImportador.conteudoArquivo.join('\n'))
         }
-
-        const resultado = this.tradutor.traduzir(retornoImportador.retornoAvaliadorSintatico.declaracoes);
 
         if(gerarArquivoSaida){
             ['.delegua', '.egua'].map(extensao => {
@@ -300,7 +316,7 @@ export class Delegua implements DeleguaInterface {
         this.importador.diretorioBase = novoDiretorioBase;
         this.interpretador.diretorioBase = novoDiretorioBase;
 
-        const retornoImportador = this.importador.importar(caminhoRelativoArquivo, true);
+        const retornoImportador = this.importador.importar(caminhoRelativoArquivo, true, false);
 
         if (this.afericaoErros(retornoImportador)) {
             process.exit(65); // Código para erro de avaliação antes da execução
diff --git a/fontes/importador/importador.ts b/fontes/importador/importador.ts
index 6f3c247c..2696e28b 100644
--- a/fontes/importador/importador.ts
+++ b/fontes/importador/importador.ts
@@ -37,7 +37,7 @@ export class Importador implements ImportadorInterface {
         this.depuracao = depuracao;
     }
 
-    importar(caminhoRelativoArquivo: string, importacaoInicial: boolean = false): RetornoImportador {
+    importar(caminhoRelativoArquivo: string, importacaoInicial: boolean = false, traduzirJavaScriptParaDelegua: boolean = false): RetornoImportador {
         const nomeArquivo = caminho.basename(caminhoRelativoArquivo);
         let caminhoAbsolutoArquivo = caminho.resolve(this.diretorioBase, caminhoRelativoArquivo);
         if (importacaoInicial) {
@@ -60,6 +60,14 @@ export class Importador implements ImportadorInterface {
             .toString()
             .replace(sistemaOperacional.EOL, '\n')
             .split('\n');
+        
+        if(traduzirJavaScriptParaDelegua){
+            return {
+                conteudoArquivo: conteudoDoArquivo,
+                nomeArquivo,
+                hashArquivo,
+            } as RetornoImportador
+        }
 
         for (let linha = 0; linha < conteudoDoArquivo.length; linha++) {
             conteudoDoArquivo[linha] += '\0';
diff --git a/fontes/importador/retorno-importador.ts b/fontes/importador/retorno-importador.ts
index 50fbe09f..fd6c597d 100644
--- a/fontes/importador/retorno-importador.ts
+++ b/fontes/importador/retorno-importador.ts
@@ -2,6 +2,7 @@ import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avalia
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
 
 export interface RetornoImportador {
+    conteudoArquivo: string[];
     nomeArquivo: string;
     hashArquivo: number;
     retornoLexador: RetornoLexador;
diff --git a/fontes/interfaces/importador-interface.ts b/fontes/interfaces/importador-interface.ts
index 0943dd42..003651b7 100644
--- a/fontes/interfaces/importador-interface.ts
+++ b/fontes/interfaces/importador-interface.ts
@@ -2,5 +2,5 @@ import { RetornoImportador } from '../importador';
 
 export interface ImportadorInterface {
     diretorioBase: string;
-    importar(caminhoRelativoArquivo: string, importacaoInicial: boolean): RetornoImportador;
+    importar(caminhoRelativoArquivo: string, importacaoInicial: boolean, traduzirJavaScriptParaDelegua: boolean): RetornoImportador;
 }
diff --git a/fontes/interpretador/interpretador.ts b/fontes/interpretador/interpretador.ts
index cd478074..b9805c50 100644
--- a/fontes/interpretador/interpretador.ts
+++ b/fontes/interpretador/interpretador.ts
@@ -813,7 +813,7 @@ export class Interpretador implements InterpretadorInterface {
             }
         }
 
-        const conteudoImportacao = this.importador.importar(caminhoRelativo, false);
+        const conteudoImportacao = this.importador.importar(caminhoRelativo, false, false);
         const retornoInterpretador = await this.interpretar(
             conteudoImportacao.retornoAvaliadorSintatico.declaracoes,
             true
diff --git a/fontes/lexador/lexador.ts b/fontes/lexador/lexador.ts
index c3c12d10..1fc4d332 100644
--- a/fontes/lexador/lexador.ts
+++ b/fontes/lexador/lexador.ts
@@ -179,17 +179,11 @@ export class Lexador implements LexadorInterface {
             }
         }
 
-        let numeroCompleto = '';
-        if(this.atual !== 0){
-            numeroCompleto = this.codigo[this.linha].substring(
+        const numeroCompleto = this.codigo[this.linha].substring(
                 this.inicioSimbolo,
                 this.atual
             );
-        } else {
-            numeroCompleto = this.codigo[this.linha - 1].substring(
-                this.inicioSimbolo
-            );
-        }
+
         this.adicionarSimbolo(
             tiposDeSimbolos.NUMERO,
             parseFloat(numeroCompleto)
@@ -205,6 +199,7 @@ export class Lexador implements LexadorInterface {
             this.inicioSimbolo,
             this.atual
         );
+
         const tipo: string =
             codigo in palavrasReservadas
                 ? palavrasReservadas[codigo]
@@ -477,6 +472,10 @@ export class Lexador implements LexadorInterface {
         this.codigo = codigo || [''];
         this.hashArquivo = hashArquivo;
 
+        for (let iterador = 0; iterador < this.codigo.length; iterador++) {
+            this.codigo[iterador] += '\0';
+        }
+
         while (!this.eFinalDoCodigo()) {
             this.inicioSimbolo = this.atual;
             this.analisarToken();
diff --git a/fontes/tradutores/index.ts b/fontes/tradutores/index.ts
new file mode 100644
index 00000000..5eef2985
--- /dev/null
+++ b/fontes/tradutores/index.ts
@@ -0,0 +1,2 @@
+export * from './tradutor-javascript';
+export * from './tradutor-reverso-javascript';
\ No newline at end of file
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 2132f4ac..637503e4 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -1,4 +1,4 @@
-import { Agrupamento, Atribuir, Binario, Chamada, DefinirValor, Isto, Literal, Variavel } from '../construtos';
+import { AcessoMetodo, Agrupamento, Atribuir, Binario, Chamada, DefinirValor, Isto, Literal, Variavel } from '../construtos';
 import {
     Bloco,
     Classe,
@@ -29,7 +29,7 @@ import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
 export class TradutorJavaScript implements TradutorInterface {
     indentacao: number = 0;
 
-    traduzirSimboloOperador(operador: SimboloInterface) {
+    traduzirSimboloOperador(operador: SimboloInterface): string {
         switch (operador.tipo) {
             case tiposDeSimbolos.ADICAO:
                 return '+';
@@ -60,26 +60,35 @@ export class TradutorJavaScript implements TradutorInterface {
         }
     }
 
-    traduzirConstrutoAgrupamento(agrupamento: Agrupamento) {
-        // TODO
-        return null;
+    traduzirConstrutoAgrupamento(agrupamento: Agrupamento): string {
+        return this.dicionarioConstrutos[agrupamento.constructor.name](agrupamento.expressao || agrupamento)
     }
 
-    traduzirConstrutoAtribuir(atribuir: Atribuir) {
+    traduzirConstrutoAtribuir(atribuir: Atribuir): string {
         let resultado = atribuir.simbolo.lexema;
         resultado += ' = ' + this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
         return resultado;
     }
 
-    traduzirConstrutoBinario(binario: Binario) {
-        let esquerda = this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda);
+    traduzirConstrutoBinario(binario: Binario): string {
+        let resultado = ''
+        if(binario.esquerda.constructor.name === 'Agrupamento')
+            resultado += '(' + this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda) + ')';
+        else
+            resultado += this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda);
+
         let operador = this.traduzirSimboloOperador(binario.operador);
-        let direita = this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita);
+        resultado += ` ${operador} `
+
+        if(binario.direita.constructor.name === 'Agrupamento')
+            resultado += '(' + this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita) + ')';
+        else
+            resultado += this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita);
 
-        return `${esquerda} ${operador} ${direita}`;
+        return resultado;
     }
 
-    traduzirConstrutoDefinirValor(definirValor: DefinirValor) {
+    traduzirConstrutoDefinirValor(definirValor: DefinirValor): string {
         let resultado = '';
         if (definirValor.objeto instanceof Isto) {
             resultado = 'this.' + definirValor.nome.lexema + ' = ';
@@ -89,27 +98,22 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirConstrutoIsto(isto: Isto) {
-        return 'this';
-    }
-
-    traduzirConstrutoLiteral(literal: Literal) {
+    traduzirConstrutoLiteral(literal: Literal): string {
         if(typeof literal.valor === 'string')
             return `'${literal.valor}'`
         return literal.valor;
     }
 
-    traduzirConstrutoVariavel(variavel: Variavel) {
+    traduzirConstrutoVariavel(variavel: Variavel): string {
         return variavel.simbolo.lexema;
     }
 
-    traduzirConstrutoChamada(chamada: Chamada) {
+    traduzirConstrutoChamada(chamada: Chamada): string {
         let resultado = '';
 
-        let entidadeChamada = chamada.entidadeChamada as Variavel;
-        resultado += `${entidadeChamada.simbolo.lexema}(`;
-        for (let parametro of chamada.argumentos as Array<Variavel>) {
-            resultado += parametro.simbolo.lexema + ', ';
+        resultado += `${this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada)}(`;
+        for (let parametro of chamada.argumentos) {
+            resultado += this.dicionarioConstrutos[parametro.constructor.name](parametro) + ', ';
         }
         if (chamada.argumentos.length > 0) {
             resultado = resultado.slice(0, -2);
@@ -118,7 +122,7 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    logicaComumBlocoEscopo(declaracoes: Declaracao[]) {
+    logicaComumBlocoEscopo(declaracoes: Declaracao[]): string {
         let resultado = '{\n';
         this.indentacao += 4;
 
@@ -141,11 +145,11 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoBloco(declaracaoBloco: Bloco) {
+    traduzirDeclaracaoBloco(declaracaoBloco: Bloco): string {
         return this.logicaComumBlocoEscopo(declaracaoBloco.declaracoes);
     }
 
-    logicaTraducaoMetodoClasse(metodoClasse: FuncaoDeclaracao) {
+    logicaTraducaoMetodoClasse(metodoClasse: FuncaoDeclaracao): string {
         this.indentacao += 4;
         let resultado = ' '.repeat(this.indentacao);
         resultado += metodoClasse.simbolo.lexema === 'construtor' ? 'constructor(' : metodoClasse.simbolo.lexema + '(';
@@ -165,7 +169,7 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoClasse(declaracaoClasse: Classe) {
+    traduzirDeclaracaoClasse(declaracaoClasse: Classe): string {
         let resultado = 'export class ';
         resultado += declaracaoClasse.simbolo.lexema + ' {\n';
 
@@ -177,7 +181,7 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoEnquanto(declaracaoEnquanto: Enquanto) {
+    traduzirDeclaracaoEnquanto(declaracaoEnquanto: Enquanto): string {
         let resultado = 'while (';
         resultado +=
             this.dicionarioConstrutos[declaracaoEnquanto.condicao.constructor.name](declaracaoEnquanto.condicao) + ') ';
@@ -185,27 +189,33 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    logicaComumCaminhosEscolha(caminho: CaminhoEscolha) {
+    logicaComumCaminhosEscolha(caminho: CaminhoEscolha): string {
         let resultado = '';
         this.indentacao += 4;
         resultado += ' '.repeat(this.indentacao);
-        for (let condicao of caminho.condicoes){
-            resultado += 'case ' + this.dicionarioConstrutos[condicao.constructor.name](condicao) + ':\n';
-            resultado += ' '.repeat(this.indentacao);
+        if(caminho?.condicoes?.length){
+            for (let condicao of caminho.condicoes){
+                resultado += 'case ' + this.dicionarioConstrutos[condicao.constructor.name](condicao) + ':\n';
+                resultado += ' '.repeat(this.indentacao);
+            }
         }
-        for (let declaracao of caminho.declaracoes) {
-            resultado += ' '.repeat(this.indentacao + 4);
-            if (declaracao?.simboloChave?.lexema === 'retorna') {
-                resultado += 'return ' + this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+        if(caminho?.declaracoes?.length){
+            for (let declaracao of caminho.declaracoes) {
+                resultado += ' '.repeat(this.indentacao + 4);
+                if (declaracao?.simboloChave?.lexema === 'retorna') {
+                    resultado += 'return ' + this.dicionarioConstrutos[declaracao.valor.constructor.name](declaracao.valor);
+                }
+                resultado += this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao) + '\n'
             }
-            resultado += this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao) + '\n'
+            resultado += ' '.repeat(this.indentacao + 4);
+            resultado += 'break'+ '\n';
         }
 
         this.indentacao -= 4;
         return resultado;
     }
 
-    traduzirDeclaracaoEscolha(declaracaoEscolha: Escolha) {
+    traduzirDeclaracaoEscolha(declaracaoEscolha: Escolha): string {
         let resultado = 'switch (';
         resultado +=
             this.dicionarioConstrutos[declaracaoEscolha.identificadorOuLiteral.constructor.name](
@@ -216,11 +226,17 @@ export class TradutorJavaScript implements TradutorInterface {
             resultado += this.logicaComumCaminhosEscolha(caminho);
         }
 
+        if(declaracaoEscolha.caminhoPadrao){
+            resultado += ' '.repeat(4);
+            resultado += 'default:\n'
+            resultado += this.logicaComumCaminhosEscolha(declaracaoEscolha.caminhoPadrao);
+        }
+
         resultado += '}\n';
         return resultado;
     }
 
-    traduzirDeclaracaoEscreva(declaracaoEscreva: Escreva) {
+    traduzirDeclaracaoEscreva(declaracaoEscreva: Escreva): string {
         let resultado = 'console.log(';
         for (const argumento of declaracaoEscreva.argumentos) {
             const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
@@ -232,11 +248,11 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoExpressao(declaracaoExpressao: Expressao) {
+    traduzirDeclaracaoExpressao(declaracaoExpressao: Expressao): string {
         return this.dicionarioConstrutos[declaracaoExpressao.expressao.constructor.name](declaracaoExpressao.expressao);
     }
 
-    traduzirDeclaracaoFazer(declaracaoFazer: Fazer) {
+    traduzirDeclaracaoFazer(declaracaoFazer: Fazer): string {
         let resultado = 'do ';
         resultado += this.dicionarioDeclaracoes[declaracaoFazer.caminhoFazer.constructor.name](
             declaracaoFazer.caminhoFazer
@@ -250,7 +266,7 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoFuncao(declaracaoFuncao: FuncaoDeclaracao) {
+    traduzirDeclaracaoFuncao(declaracaoFuncao: FuncaoDeclaracao): string {
         let resultado = 'function ';
         resultado += declaracaoFuncao.simbolo.lexema + ' (';
 
@@ -276,7 +292,7 @@ export class TradutorJavaScript implements TradutorInterface {
         throw new Error('`leia()` não é suportado por este padrão de JavaScript.');
     }
 
-    traduzirDeclaracaoPara(declaracaoPara: Para) {
+    traduzirDeclaracaoPara(declaracaoPara: Para): string {
         let resultado = 'for (';
         resultado +=
             this.dicionarioDeclaracoes[declaracaoPara.inicializador.constructor.name](declaracaoPara.inicializador) +
@@ -290,26 +306,13 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoRetorna(declaracaoRetorna: Retorna) {
+    traduzirDeclaracaoRetorna(declaracaoRetorna: Retorna): string {
         let resultado = 'return ';
-        const nomeConstrutor = declaracaoRetorna?.valor?.expressao?.constructor?.name;
-        if (declaracaoRetorna?.valor instanceof Binario) {
-            return (resultado += this.traduzirConstrutoBinario(declaracaoRetorna?.valor));
-        }
-        if (declaracaoRetorna?.valor instanceof Literal) {
-            const valor = this.traduzirConstrutoLiteral(declaracaoRetorna?.valor as Literal);
-            resultado += valor
-            return resultado;
-        }
-        if (this.dicionarioConstrutos.hasOwnProperty(nomeConstrutor)) {
-            resultado += this.dicionarioConstrutos[nomeConstrutor](declaracaoRetorna.valor.expressao);
-        } else {
-            resultado += this.dicionarioDeclaracoes[nomeConstrutor](declaracaoRetorna.valor.expressao);
-        }
-        return resultado;
+        const nomeConstrutor = declaracaoRetorna.valor.constructor.name;
+        return resultado += this.dicionarioConstrutos[nomeConstrutor](declaracaoRetorna?.valor);
     }
 
-    traduzirDeclaracaoSe(declaracaoSe: Se) {
+    traduzirDeclaracaoSe(declaracaoSe: Se): string {
         let resultado = 'if (';
 
         const condicao = this.dicionarioConstrutos[declaracaoSe.condicao.constructor.name](declaracaoSe.condicao);
@@ -343,7 +346,7 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoTente(declaracaoTente: Tente) {
+    traduzirDeclaracaoTente(declaracaoTente: Tente): string {
         let resultado = 'try {\n';
         this.indentacao += 4;
         resultado += ' '.repeat(this.indentacao);
@@ -375,33 +378,29 @@ export class TradutorJavaScript implements TradutorInterface {
         return resultado;
     }
 
-    traduzirDeclaracaoVar(declaracaoVar: Var) {
+    traduzirDeclaracaoVar(declaracaoVar: Var): string {
         let resultado = 'let ';
         resultado += declaracaoVar.simbolo.lexema + ' = ';
-        if (declaracaoVar.inicializador instanceof Literal) {
-            resultado += this.dicionarioConstrutos[declaracaoVar.inicializador.constructor.name](
-                declaracaoVar.inicializador
-            );
-        } else if (declaracaoVar.inicializador instanceof Binario) {
-            resultado += this.dicionarioConstrutos[declaracaoVar.inicializador.constructor.name](
-                declaracaoVar.inicializador
-            );
-        } else {
-            resultado += this.dicionarioDeclaracoes[declaracaoVar.inicializador.constructor.name](
-                declaracaoVar.inicializador
-            );
-        }
-
+        resultado += this.dicionarioConstrutos[declaracaoVar.inicializador.constructor.name](declaracaoVar.inicializador);
         return resultado;
     }
 
+    trazudirConstrutoAcessoMetodo(acessoMetodo: AcessoMetodo): string {
+        if(acessoMetodo.objeto instanceof Variavel){
+            let objetoVariavel = acessoMetodo.objeto as Variavel
+            return `${objetoVariavel.simbolo.lexema}.${acessoMetodo.simbolo.lexema}`
+        }
+        return `this.${acessoMetodo.simbolo.lexema}`;
+    }
+
     dicionarioConstrutos = {
+        AcessoMetodo: this.trazudirConstrutoAcessoMetodo.bind(this),
         Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
         Atribuir: this.traduzirConstrutoAtribuir.bind(this),
         Binario: this.traduzirConstrutoBinario.bind(this),
         Chamada: this.traduzirConstrutoChamada.bind(this),
         DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
-        Isto: this.traduzirConstrutoIsto.bind(this),
+        Isto: () => 'this',
         Literal: this.traduzirConstrutoLiteral.bind(this),
         Variavel: this.traduzirConstrutoVariavel.bind(this),
     };
@@ -426,7 +425,7 @@ export class TradutorJavaScript implements TradutorInterface {
         Var: this.traduzirDeclaracaoVar.bind(this),
     };
 
-    traduzir(declaracoes: Declaracao[]) {
+    traduzir(declaracoes: Declaracao[]): string {
         let resultado = '';
 
         for (const declaracao of declaracoes) {
diff --git a/fontes/tradutores/tradutor-reverso-javascript.ts b/fontes/tradutores/tradutor-reverso-javascript.ts
index 689b0baa..87726e83 100644
--- a/fontes/tradutores/tradutor-reverso-javascript.ts
+++ b/fontes/tradutores/tradutor-reverso-javascript.ts
@@ -4,31 +4,139 @@ import { parseScript } from 'esprima';
  * Esse tradutor traduz de JavaScript para Delégua
  */
 export class TradutorReversoJavaScript {
+    indentacao: number = 0;
 
     constructor() {}
 
-    traduzirDeclaracaoDeVariavel(declaracao: any) {
+    traduzirSimboloOperador(operador: any): string {
+        switch (operador) {
+            case '==':
+            case '===':
+                return '==';
+        }
+    }
+
+    dicionarioConstrutos = {
+        ArrowFunctionExpression: this.traduzirDeclaracaoFuncao.bind(this),
+        // Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
+        // Atribuir: this.traduzirConstrutoAtribuir.bind(this),
+        BinaryExpression: this.traduzirConstrutoBinario.bind(this),
+        // Chamada: this.traduzirConstrutoChamada.bind(this),
+        // DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
+        // Isto: this.traduzirConstrutoIsto.bind(this),
+        Literal: this.traduzirConstrutoLiteral.bind(this),
+        // Variavel: this.traduzirConstrutoVariavel.bind(this),
+    };
+
+    dicionarioDeclaracoes = {
+        ExpressionStatement: this.traduzirExpressaoDeclaracao.bind(this)
+        // traduzirDeclaracaoEscreva
+    }
+
+    traduzirExpressaoDeclaracao(declaracao): string {
+        let resultado = '';
+        let informacoesExpressao = declaracao.expression.callee
+        if(informacoesExpressao.type === 'MemberExpression'){
+            if(informacoesExpressao?.object?.name === 'console' && informacoesExpressao?.property?.name === 'log'){
+                for(let argumento of declaracao.expression.arguments){
+                    resultado += `escreva(${this.dicionarioConstrutos[argumento.type](argumento)})`
+                }
+            }
+        }
+        return resultado;
+    }
+
+    traduzirDeclaracaoFuncao(funcao: any): string {
+        console.log(funcao)
+        return ''
+    }
+
+    traduzirConstrutoLiteral(literal: any): string {
+        let resultado = '';
+        if (typeof literal.value === 'string')
+            resultado += `'${literal.value}'`;
+        else
+            resultado += `${literal.value}`;
+        
+        return resultado;
+    }
+
+    traduzirConstrutoBinario(binario: any): string {
+        let resultado = '';
+        let direita = typeof binario.right.value === 'string' ? `'${binario.right.value}'` : binario.right.value;
+        let esquerda = typeof binario.left.value === 'string' ? `'${binario.left.value}'` : binario.left.value;
+        resultado += `${esquerda} ${this.traduzirSimboloOperador(binario.operator)} ${direita}`
+        return resultado;
+    }
+
+    traduzirDeclaracaoDeVariavel(declaracao: any): string {
         let informacoesDaVariavel = declaracao.declarations[0];
-        let resultado = `var ${informacoesDaVariavel.id.name} = `;
-        if (typeof informacoesDaVariavel.init.value === 'string'){
-            resultado += `'${informacoesDaVariavel.init.value}'`;
-        } else {
-            resultado += `${informacoesDaVariavel.init.value}`;
+        let resultado = `var ${informacoesDaVariavel.id.name} = ${this.dicionarioConstrutos[informacoesDaVariavel.init.type](informacoesDaVariavel.init)}`;
+
+        return resultado;
+    }
+
+    logicaComumBlocoEscopo(declaracoes: any): string {
+        let resultado = '{\n';
+        this.indentacao += 4;
+
+        // if (typeof declaracoes[Symbol.iterator] === 'function') {
+            for (const declaracaoOuConstruto of declaracoes.body.body) {
+                resultado += ' '.repeat(this.indentacao);
+                const nomeConstrutor = declaracaoOuConstruto.constructor.name;
+                if (this.dicionarioConstrutos.hasOwnProperty(nomeConstrutor)) {
+                    resultado += this.dicionarioConstrutos[nomeConstrutor](declaracaoOuConstruto);
+                } else {
+                    resultado += this.dicionarioDeclaracoes[nomeConstrutor](declaracaoOuConstruto);
+                }
+
+                resultado += '\n';
+            }
+        // }
+
+        this.indentacao -= 4;
+        resultado += ' '.repeat(this.indentacao) + '}\n';
+        return resultado;
+    }
+
+    traduzirDeclaracaoDeFuncao(declaracao: any): string {
+        let resultado = '';
+        resultado += `funcao ${declaracao.id.name}(`
+
+        for(let parametro of declaracao.params){
+            resultado += parametro.name + ', '
+        }
+        if (declaracao.params.length > 0) {
+            resultado = resultado.slice(0, -2);
         }
+        resultado += ') '
+        resultado += this.logicaComumBlocoEscopo(declaracao)
         return resultado;
     }
 
-    traduzirDeclaracao(declaracao: any) {
+    traduzirClasseDeclaracao(declaracao: any){
+        let resultado = ''
+        
+        console.log(declaracao)
+        return ''
+    }
+
+    traduzirDeclaracao(declaracao: any): string {
         switch (declaracao.type) {
+            case 'ClassDeclaration':
+                return this.traduzirClasseDeclaracao(declaracao);
+            case 'ExpressionStatement':
+                return this.traduzirExpressaoDeclaracao(declaracao);
+            case 'FunctionDeclaration':
+                return this.traduzirDeclaracaoDeFuncao(declaracao);
             case 'VariableDeclaration':
                 return this.traduzirDeclaracaoDeVariavel(declaracao);
         }
     }
 
-    traduzir() {
+    traduzir(codigo): string {
         let resultado = '';
-        const programa = 'const a = 42\nconst b = \'a\'';
-        const declaracoes = parseScript(programa);
+        const declaracoes = parseScript(codigo);
 
         for (let declaracao of declaracoes.body) {
             resultado += `${this.traduzirDeclaracao(declaracao)} \n`;
@@ -40,5 +148,5 @@ export class TradutorReversoJavaScript {
 
 //cd ./fontes/tradutores
 //ts-node -T tradutor-reverso-javascript.ts
-var tjs = new TradutorReversoJavaScript();
-tjs.traduzir();
\ No newline at end of file
+// var tjs = new TradutorReversoJavaScript();
+// tjs.traduzir();
\ No newline at end of file


Test patch:
diff --git a/testes/delegua.test.ts b/testes/delegua.test.ts
index a8c0dfa9..fe938072 100644
--- a/testes/delegua.test.ts
+++ b/testes/delegua.test.ts
@@ -1,4 +1,5 @@
 import { Delegua } from '../fontes/delegua';
+import { TradutorJavaScript, TradutorReversoJavaScript } from '../fontes/tradutores';
 
 describe('Delégua', () => {
     let delegua: Delegua;
@@ -13,5 +14,22 @@ describe('Delégua', () => {
 
             expect(versaoDelegua).toBeTruthy();
         });
+
+        it('Traduzir delégua para javascript', () => {
+            expect(new Delegua('', false, false, 'js').tradutorJavaScript).toBeInstanceOf(TradutorJavaScript);
+            expect(new Delegua('', false, false, 'javascript').tradutorJavaScript).toBeInstanceOf(TradutorJavaScript);
+        });
+
+        it('Traduzir javascript para delégua', () => {
+            expect(new Delegua('', false, false, 'delegua').tradutorReversoJavascript).toBeInstanceOf(TradutorReversoJavaScript);
+        });
+    });
+
+    describe('Falha', () => {
+        it('Tradutor', () => {
+            expect(() => new Delegua('', false, false, 'go')).toThrow(
+                new Error('Tradutor \'go\' não implementado.')
+            );
+        });
     });
 });
diff --git a/testes/tradutores/tradutor-javascript.test.ts b/testes/tradutores/tradutor-javascript.test.ts
index ec2eb636..4180d987 100644
--- a/testes/tradutores/tradutor-javascript.test.ts
+++ b/testes/tradutores/tradutor-javascript.test.ts
@@ -37,6 +37,96 @@ describe('Tradutor Delégua -> JavaScript', () => {
             delegua = new Delegua('delegua');
         });
 
+        it('agrupamento', () => {
+            const retornoLexador = delegua.lexador.mapear(
+                [
+                    "var agrupamento = (2 * 2) + 5 - 1 ** (2 + 3 - 4)",
+                    "escreva(agrupamento)"
+                ],
+                -1
+            );
+            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
+
+            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/let agrupamento = \(2 \* 2\) \+ 5 - 1 \** \(2 \+ 3 - 4\)/i);
+            expect(resultado).toMatch(/console\.log\(agrupamento\)/i);
+        });
+
+        it('isto -> this', () => {
+            const retornoLexador = delegua.lexador.mapear(
+                [
+                    'classe Teste {',
+                        'construtor(abc){',
+                            'isto.valor = abc',
+                        '}',
+                        'mostrarValor() {',
+                            'escreva(isto.valor)',
+                        '}',
+                    '}',
+                    'var teste = Teste(100);',
+                    'teste.mostrarValor()'
+                ],
+                -1
+            );
+            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
+
+            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/class Teste {/i);
+            expect(resultado).toMatch(/constructor\(abc\)/i);
+            expect(resultado).toMatch(/this.valor = abc/i);
+            expect(resultado).toMatch(/mostrarValor\(\) {/i);
+            expect(resultado).toMatch(/console\.log\(this.valor\)/i);
+            expect(resultado).toMatch(/let teste = Teste\(100\)/i);
+            expect(resultado).toMatch(/teste.mostrarValor\(\)/i);
+        });
+
+        it('para/sustar -> for/break', () => {
+            const retornoLexador = delegua.lexador.mapear(
+                [
+                    'para (var i = 0; i < 5; i = i + 1) {',
+                        'se(i == 3) {',
+                            'sustar;',
+                        '}',
+                        'escreva(i);',
+                    '}',
+                ],
+                -1
+            );
+            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
+
+            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/for \(/i);
+            expect(resultado).toMatch(/if \(/i);
+            expect(resultado).toMatch(/\(\i === 3\)/i);
+            expect(resultado).toMatch(/break/i);
+            expect(resultado).toMatch(/console\.log\(i\)/i);
+        });
+
+        it('para/continue -> for/continue', () => {
+            const retornoLexador = delegua.lexador.mapear(
+                [
+                    'para (var i = 0; i < 5; i = i + 1) {',
+                        'se(i == 3) {',
+                            'continua',
+                        '}',
+                        'escreva(i);',
+                    '}',
+                ],
+                -1
+            );
+            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
+
+            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/for \(/i);
+            expect(resultado).toMatch(/if \(i === 3\)/i);
+            expect(resultado).toMatch(/continue/i);
+            expect(resultado).toMatch(/console\.log\(i\)/i);
+        });
+
         it('para -> for', () => {
             const retornoLexador = delegua.lexador.mapear(
                 [
@@ -50,8 +140,9 @@ describe('Tradutor Delégua -> JavaScript', () => {
 
             const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
             expect(resultado).toBeTruthy();
-            // expect(resultado).toMatch(/for (let i = 0; i < 5; i = i + 1) {/i);
+            expect(resultado).toMatch(/for \(let i = 0; i < 5; i = i \+ 1\) {/i);
             expect(resultado).toMatch(/console\.log\(i\)/i);
+            expect(resultado).toMatch(/}/i);
         });
 
         it('enquanto -> while', () => {
@@ -72,7 +163,7 @@ describe('Tradutor Delégua -> JavaScript', () => {
             expect(resultado).toMatch(/let i = 0/i);
             expect(resultado).toMatch(/do {/i);
             expect(resultado).toMatch(/console\.log\(i\)/i);
-            // expect(resultado).toMatch(/i = i + 1/i);
+            expect(resultado).toMatch(/i = i \+ 1/i);
             expect(resultado).toMatch(/}/i);
             expect(resultado).toMatch(/while \(i < 5\)/i);
         });
@@ -90,7 +181,7 @@ describe('Tradutor Delégua -> JavaScript', () => {
 
             const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
             expect(resultado).toBeTruthy();
-            // expect(resultado).toMatch(/while \(true\) {/i);
+            expect(resultado).toMatch(/while \(true\) {/i);
             expect(resultado).toMatch(/console\.log\('sim'\)/i);
             expect(resultado).toMatch(/}/i);
         });
@@ -108,7 +199,7 @@ describe('Tradutor Delégua -> JavaScript', () => {
 
             const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
             expect(resultado).toBeTruthy();
-            // expect(resultado).toMatch(/while (true) {/i);
+            expect(resultado).toMatch(/while \(true\) {/i);
             expect(resultado).toMatch(/console\.log\(\'sim\'\)/i);
             expect(resultado).toMatch(/}/i);
         });
@@ -171,6 +262,8 @@ describe('Tradutor Delégua -> JavaScript', () => {
             expect(resultado).toMatch(/console\.log\('correspondente à opção 2'\)/i);
             expect(resultado).toMatch(/console\.log\('escreva de novo 2'\)/i);
             expect(resultado).toMatch(/console\.log\('escreva de novo 3'\)/i);
+            // expect(resultado).toMatch(/default:'\)/i);
+            expect(resultado).toMatch(/console\.log\('Sem opção correspondente'\)/i);
         });
         
         it('classe com parametros -> class', () => {
@@ -350,18 +443,18 @@ describe('Tradutor Delégua -> JavaScript', () => {
 
             const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
             expect(resultado).toBeTruthy();
-            // expect(resultado).toMatch(/let soma = 1 + 1/i);
+            expect(resultado).toMatch(/let soma = 1 \+ 1/i);
             expect(resultado).toMatch(/let subtracao = 1 - 1/i);
-            // expect(resultado).toMatch(/let diferente = 1 !== 1/i);
-            // expect(resultado).toMatch(/let igual = 1 === 1/i);
-            // expect(resultado).toMatch(/let divisao = 1 / 1/i);
+            expect(resultado).toMatch(/let diferente = 1 !== 1/i);
+            expect(resultado).toMatch(/let igual = 1 === 1/i);
+            expect(resultado).toMatch(/let divisao = 1 \/ 1/i);
             expect(resultado).toMatch(/let menor = 1 < 1/i);
             expect(resultado).toMatch(/let maior = 1 > 1/i);
-            // expect(resultado).toMatch(/let maiorOuIgual = 1 >= 1/i);
-            // expect(resultado).toMatch(/let menorOuIgual = 1 <= 1/i);
-            // expect(resultado).toMatch(/let multiplicacao = 1 * 1/i);
-            // expect(resultado).toMatch(/let modulo = 1 % 1/i);
-            // expect(resultado).toMatch(/let exponenciacao = 1 ** 1/i);
+            expect(resultado).toMatch(/let maiorOuIgual = 1 >= 1/i);
+            expect(resultado).toMatch(/let menorOuIgual = 1 <= 1/i);
+            expect(resultado).toMatch(/let multiplicacao = 1 \* 1/i);
+            expect(resultado).toMatch(/let modulo = 1 % 1/i);
+            expect(resultado).toMatch(/let exponenciacao = 1 \** 1/i);
             expect(resultado).toMatch(
                 /console\.log\(soma, subtracao, diferente, igual, divisao, menor, maior, maiorOuIgual, menorOuIgual, multiplicacao, modulo, exponenciacao\)/i
             );
@@ -489,8 +582,6 @@ describe('Tradutor Delégua -> JavaScript', () => {
             expect(resultado).toMatch(/console\.log\(teste\)/i);
         });
 
-        //TODO: Pulando pois no CI esta quebrando, mas localmente o teste passa normal
-        //Alterar a regex do ultimo expect deve resolver
         it('função -> function - sem parametro', () => {
             const retornoLexador = delegua.lexador.mapear(
                 ['funcao minhaFuncaoSemParametro() {', "    escreva('teste')", '}'],
diff --git a/testes/tradutores/tradutor-reverso-javascript.test.ts b/testes/tradutores/tradutor-reverso-javascript.test.ts
index 7be75cbf..bcc90ef1 100644
--- a/testes/tradutores/tradutor-reverso-javascript.test.ts
+++ b/testes/tradutores/tradutor-reverso-javascript.test.ts
@@ -1,9 +1,4 @@
-import { Binario, Variavel, Literal } from '../../fontes/construtos';
-import { Se, Bloco, Escreva } from '../../fontes/declaracoes';
-import { Simbolo } from '../../fontes/lexador';
 import { TradutorReversoJavaScript } from '../../fontes/tradutores/tradutor-reverso-javascript';
-
-import tiposDeSimbolos from '../../fontes/tipos-de-simbolos/delegua';
 import { Delegua } from '../../fontes/delegua';
 
 describe('Tradutor Reverso Javascript -> Delégua', () => {
@@ -16,20 +11,70 @@ describe('Tradutor Reverso Javascript -> Delégua', () => {
             delegua = new Delegua('delegua');
         });
 
-        it('', () => {
-            // const retornoLexador = delegua.lexador.mapear(
-            //     [
-            //         'para (var i = 0; i < 5; i = i + 1) {',
-            //             'escreva(i);',
-            //         '}',
-            //     ],
-            //     -1
-            // );
-            // const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
-
-            // const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
-            // expect(resultado).toBeTruthy();
-            // expect(resultado).toMatch(/console\.log\(i\)/i);
+        it('comparacao de valores -> igualdade', () => {
+            const codigo = `console.log(1 === 2)\nconsole.log(1 == '1')\nconsole.log('1' === '1')`
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/escreva\(1 == 2\)/i);
+            expect(resultado).toMatch(/escreva\(1 == '1'\)/i);
+            expect(resultado).toMatch(/escreva\('1' == '1'\)/i);
+        });
+
+        it('console.log -> escreva', () => {
+            const codigo = `console.log('Oi')`
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/escreva\('Oi'\)/i);
         });
+
+        it('const/let/var -> var', () => {
+            const codigo = `const a = 1\nlet b = 2\nvar c = 3`
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var a = 1/i);
+            expect(resultado).toMatch(/var b = 2/i);
+            expect(resultado).toMatch(/var c = 3/i);
+        });
+
+        it('function -> funcao sem parametro', () => {
+            const codigo = `function teste() {console.log(\'Oi\')\nconsole.log(123)}`
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(\)/i);
+            expect(resultado).toMatch(/escreva\('Oi'\)/i);
+            expect(resultado).toMatch(/escreva\(123\)/i);
+        });
+
+        it('function -> funcao com parametro', () => {
+            const codigo = `function teste(a, b, c) {console.log(\'Oi\')}`
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/escreva\('Oi'\)/i);
+        });
+
+        // it('class -> classe', () => {
+        //     const codigo = `
+        //         class Rectangle {
+        //             constructor(height, width, abc) {
+        //                 this.height = height;
+        //                 this.width = width;
+        //             }
+
+        //             teste(){
+        //                 console.log('oi')
+        //             }
+        //         }
+        //     `
+
+        //     const resultado = tradutor.traduzir(codigo);
+        //     // expect(resultado).toBeTruthy();
+        //     // expect(resultado).toMatch(/console\.log\(i\)/i);
+        // });
     });
 });