Repository: DesignLiquido/delegua
Pull request #254 (2023-01-29 04:43:45)

Tradutor - Javascript para Delégua
#202

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: 67.8%">68.09% (+0.29% 🔼)</div>  |    3833/5629    |
|                                                                           🔴                                                                           | Branches   | <div title="Base coverage is: 56.55%">57.25% (+0.7% 🔼)</div>  |    1188/2075    |
|                                                                           🟡                                                                           | Functions  | <div title="Base coverage is: 67.77%">67.81% (+0.04% 🔼)</div> |     554/817     |
|                                                                           🟡                                                                           | Lines      | <div title="Base coverage is: 68.08%">68.38% (+0.3% 🔼)</div>  |    3709/5424    |


<details><summary>Show files with reduced coverage 🔻</summary>
<br/>

| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | File                                                                                                | Statements                                                     | Branches                                                       | Functions                                                      | Lines                                                          |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------- | :------------------------------------------------------------- | :------------------------------------------------------------- | :------------------------------------------------------------- | :------------------------------------------------------------- |
|                                                                           🟢                                                                           | <div title="tradutores/tradutor-reverso-javascript.ts">`...` / tradutor-reverso-javascript.ts</div> | <div title="Base coverage is: 89.06%">95.41% (+6.35% 🔼)</div> | <div title="Base coverage is: 82.86%">81.25% (-1.61% 🔻)</div> | <div title="Base coverage is: 83.33%">84.62% (+1.28% 🔼)</div> | <div title="Base coverage is: 88.89%">95.37% (+6.48% 🔼)</div> |

</details>

## Test suite run success
260 tests passing in 23 suites.

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

Patch:
diff --git a/README.md b/README.md
index 1bae5cca..7505c8b3 100644
--- a/README.md
+++ b/README.md
@@ -53,6 +53,8 @@ Delégua tem retrocompatibilidade com a linguagem Égua e compreende sua extens
 - **Grátis.** Sem planos, sem limitações e sem propaganda.
 - **Código aberto (_open source_).** Todo o código fonte disponível para estudar, modificar e contribuir.
 - **Linguagem Científica.** Apoiamos e encorajamos o desenvolvimento e aprimoramento da ciência e da educação.
+- **Multidialetos.** Execute algoritmos em [Portugol VisuAlg](http://visualg3.com.br).
+- **Depurável.** Usando um editor com suporte à depuração como o [Visual Studio Code](https://code.visualstudio.com), você pode inspecionar o seu programa, suas variáveis e executar linha por linha
 
 ## Aplicações
 
@@ -60,12 +62,15 @@ Delégua tem retrocompatibilidade com a linguagem Égua e compreende sua extens
 
 ## Instalação
 
-Delégua executa em qualquer dispositivo que interprete JavaScript, ou seja, computadores, celulares e tablets. Você não precisa instalar nada se não quiser: [basta usar nosso editor online clicando aqui](https://designliquido.github.io/delegua-web/).
+Delégua executa em qualquer dispositivo que interprete JavaScript, ou seja, computadores, celulares e tablets. Você não precisa instalar nada se não quiser: utilize uma das seguintes opções: 
+
+- [Dentro do Visual Studio Code, instale a extensão da Design Líquido](https://marketplace.visualstudio.com/items?itemName=designliquido.designliquido-vscode). [Aprenda como executar e depurar seu programa aqui](https://www.youtube.com/watch?v=TQxLekzvBv8);
+- [Utilize nosso editor online](https://designliquido.github.io/delegua-web/).
 
 Se quiser instalar no seu computador,
 [você deve ter antes o Node.js instalado em seu ambiente](https://dicasdejavascript.com.br/instalacao-do-nodejs-e-npm-no-windows-passo-a-passo).
 
-Com o Node.js instalado, execute o seguinte comando em um _prompt_ de comando (Terminal, PowerShell ou `cmd` no Windows, Terminal ou `bash` em Mac e Linux):
+Com o Node.js instalado, execute o seguinte comando em um _prompt_ de comando (Terminal, PowerShell ou `cmd` no Windows, Terminal ou `sh` em Mac e Linux):
 
 ```
 npm install -g delegua
diff --git a/fontes/tradutores/tradutor-reverso-javascript.ts b/fontes/tradutores/tradutor-reverso-javascript.ts
index e71ebff7..a8d268c3 100644
--- a/fontes/tradutores/tradutor-reverso-javascript.ts
+++ b/fontes/tradutores/tradutor-reverso-javascript.ts
@@ -1,4 +1,24 @@
 import { parseScript } from 'esprima';
+import {
+    ArrayExpression,
+    BinaryExpression,
+    BlockStatement,
+    ClassDeclaration,
+    DoWhileStatement,
+    ForStatement,
+    Identifier,
+    IfStatement,
+    Literal,
+    MemberExpression,
+    MethodDefinition,
+    NewExpression,
+    ReturnStatement,
+    TryStatement,
+    UpdateExpression,
+    VariableDeclaration,
+    WhileStatement
+} 
+from 'estree';
 
 /**
  * Esse tradutor traduz de JavaScript para Delégua.
@@ -15,65 +35,128 @@ export class TradutorReversoJavaScript {
             case '==':
             case '===':
                 return '==';
+            default:
+                return operador;
         }
     }
 
+    traduzirConstrutoVetor(vetor: ArrayExpression){
+        if(!vetor.elements.length){
+            return '[]'
+        }
+
+        let resultado = '['
+
+        for(let elemento of vetor.elements){
+            resultado += this.dicionarioConstrutos[elemento.constructor.name](elemento) + ', '
+        }
+        if (vetor.elements.length > 0) {
+            resultado = resultado.slice(0, -2);
+        }
+        resultado += ']'
+        return resultado;
+    }
+
+    traduzirIdentificador(identificador: Identifier): string {
+        return identificador.name;
+    }
+
+    traduzirAtualizacaoVariavel(atualizarVariavel: UpdateExpression): string {
+        let resultado = '';
+        resultado += this.dicionarioConstrutos[atualizarVariavel.argument.constructor.name](atualizarVariavel.argument)
+        resultado += this.traduzirSimboloOperador(atualizarVariavel.operator);
+        return resultado;
+    }
+
+    traduzirNovo(novo: NewExpression){
+        let identificador = novo.callee as Identifier;
+
+        let resultado = `${identificador.name}(`;
+
+        for (let argumento of novo.arguments){
+            resultado += this.dicionarioConstrutos[argumento.type](argumento) + ', '
+        }
+        if (novo.arguments.length > 0) {
+            resultado = resultado.slice(0, -2);
+        }
+
+        resultado += ')'
+        return resultado;
+    }
+
+    traduzirExpressao(expressao: MemberExpression): string {
+        let objeto = this.dicionarioConstrutos[expressao.object.type](expressao.object)
+        let propriedade = this.dicionarioConstrutos[expressao.property.type](expressao.property)
+        if(objeto === 'console' && propriedade === 'log'){
+            return 'escreva'
+        }
+        return `${objeto}${propriedade}`;
+    }
+
     dicionarioConstrutos = {
+        AssignmentExpression: this.traduzirConstrutoAtribuir.bind(this),
+        ArrayExpression: this.traduzirConstrutoVetor.bind(this),
         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),
+        CallExpression: this.traduzirConstrutoChamada.bind(this),
         // DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
         // Isto: this.traduzirConstrutoIsto.bind(this),
+        Identifier: this.traduzirIdentificador.bind(this),
         Literal: this.traduzirConstrutoLiteral.bind(this),
+        MemberExpression: this.traduzirExpressao.bind(this),
+        NewExpression: this.traduzirNovo.bind(this),
+        ThisExpression: (expressao) => 'isto.',
+        UpdateExpression: this.traduzirAtualizacaoVariavel.bind(this)
         // Variavel: this.traduzirConstrutoVariavel.bind(this),
     };
 
-    dicionarioDeclaracoes = {
-        ExpressionStatement: this.traduzirExpressaoDeclaracao.bind(this),
-        // traduzirDeclaracaoEscreva
-    };
-
-    traduzirExpressaoDeclaracao(declaracao): string {
+    traduzirConstrutoChamada(chamada: any) {
         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)})`;
-                }
-            }
+        resultado += this.dicionarioConstrutos[chamada.callee.type](chamada.callee) + '('
+        for (let parametro of chamada.arguments) {
+            resultado += this.dicionarioConstrutos[parametro.type](parametro) + ', ';
         }
+        if (chamada.arguments.length > 0) {
+            resultado = resultado.slice(0, -2);
+        }
+        resultado += ')';
         return resultado;
     }
 
-    traduzirDeclaracaoFuncao(funcao: any): string {
-        console.log(funcao);
-        return '';
+    traduzirConstrutoAtribuir(atribuir: any): string {
+        let resultado = '';
+        const direita = this.dicionarioConstrutos[atribuir.right.type](atribuir.right);
+        const esquerda = this.dicionarioConstrutos[atribuir.left.type](atribuir.left);
+        resultado += `${esquerda} ${this.traduzirSimboloOperador(atribuir.operator)} ${direita}`;
+        return resultado;
     }
 
-    traduzirConstrutoLiteral(literal: any): string {
-        let resultado = '';
-        if (typeof literal.value === 'string') resultado += `'${literal.value}'`;
-        else resultado += `${literal.value}`;
+    traduzirExpressaoDeclaracao(declaracao): string {
+        return this.dicionarioConstrutos[declaracao.expression.type](declaracao.expression)
+    }
 
-        return resultado;
+    traduzirConstrutoLiteral(literal: Literal): string {
+        return `${literal.raw}`;
     }
 
-    traduzirConstrutoBinario(binario: any): string {
+    traduzirConstrutoBinario(binario: BinaryExpression): 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;
+        const direita = this.dicionarioConstrutos[binario.right.type](binario.right);
+        const esquerda = this.dicionarioConstrutos[binario.left.type](binario.left);
         resultado += `${esquerda} ${this.traduzirSimboloOperador(binario.operator)} ${direita}`;
         return resultado;
     }
 
-    traduzirDeclaracaoDeVariavel(declaracao: any): string {
+    traduzirDeclaracaoVariavel(declaracao: VariableDeclaration): string {
+        let resultado = ''
         let informacoesDaVariavel = declaracao.declarations[0];
-        let resultado = `var ${informacoesDaVariavel.id.name} = ${this.dicionarioConstrutos[
-            informacoesDaVariavel.init.type
-        ](informacoesDaVariavel.init)}`;
+        const identificador = informacoesDaVariavel.id as Identifier;
+        if(identificador){
+            resultado += `var ${identificador.name} = ${this.dicionarioConstrutos[
+                informacoesDaVariavel.init.type
+            ](informacoesDaVariavel.init)}`;
+        }
 
         return resultado;
     }
@@ -82,26 +165,36 @@ export class TradutorReversoJavaScript {
         let resultado = '{\n';
         this.indentacao += 4;
 
-        // if (typeof declaracoes[Symbol.iterator] === 'function') {
-        for (const declaracaoOuConstruto of declaracoes.body.body) {
+        const corpo = declaracoes.body.body || declaracoes.body;
+        for (const declaracaoOuConstruto of corpo) {
             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 += this.traduzirDeclaracao(declaracaoOuConstruto);
             }
 
             resultado += '\n';
         }
-        // }
 
         this.indentacao -= 4;
         resultado += ' '.repeat(this.indentacao) + '}\n';
         return resultado;
     }
 
-    traduzirDeclaracaoDeFuncao(declaracao: any): string {
+    traduzirDeclaracaoPara(declaracao: ForStatement): string{
+        let resultado = ''
+        resultado += 'para ('
+        resultado += this.traduzirDeclaracao(declaracao.init) + '; '
+        resultado += this.dicionarioConstrutos[declaracao.test.type](declaracao.test) + '; '
+        resultado += this.dicionarioConstrutos[declaracao.update.type](declaracao.update) + ') '
+        resultado += this.logicaComumBlocoEscopo(declaracao);
+
+        return resultado;
+    }
+
+    traduzirDeclaracaoFuncao(declaracao: any): string {
         let resultado = '';
         resultado += `funcao ${declaracao.id.name}(`;
 
@@ -116,23 +209,140 @@ export class TradutorReversoJavaScript {
         return resultado;
     }
 
-    traduzirClasseDeclaracao(declaracao: any) {
-        let resultado = '';
+    //TODO: Refatorar esse método. @Samuel
+    traduzirDeclaracaoClasse(declaracao: ClassDeclaration) {
+        let resultado = `classe ${declaracao.id.name} `;
+        if (declaracao.superClass) {
+            let identificador = declaracao.superClass as Identifier;
+            resultado += `herda ${identificador.name} `;
+        }
+        resultado += '{\n'
+        this.indentacao += 4;
+        resultado += ' '.repeat(this.indentacao);
+
+        for(let corpo of declaracao.body.body) {
+            if(corpo.type === 'MethodDefinition'){
+                let _corpo = corpo as MethodDefinition;
+                if(_corpo.kind === 'constructor'){
+                    resultado += 'construtor('
+                    for (let valor of _corpo.value.params){
+                        if(valor.type === 'Identifier'){
+                            resultado += `${valor.name}, `
+                        }
+                    }
+                    if (_corpo.value.params.length > 0) {
+                        resultado = resultado.slice(0, -2);
+                    }
+                    resultado += ')'
+                    resultado += this.logicaComumBlocoEscopo(_corpo.value)
+                } else if (_corpo.kind === 'method'){
+                    resultado += ' '.repeat(this.indentacao);
+                    let identificador = _corpo.key as Identifier
+                    resultado += identificador.name + '('
+                    for (let valor of _corpo.value.params){
+                        if(valor.type === 'Identifier'){
+                            resultado += `${valor.name}, `
+                        }
+                    }
+                    if (_corpo.value.params.length > 0) {
+                        resultado = resultado.slice(0, -2);
+                    }
+                    resultado += ')'
+                    resultado += this.logicaComumBlocoEscopo(_corpo.value)
+                }
+            } else if (corpo.constructor.name === 'PropertyDefinition'){
+
+            } else if (corpo.constructor.name === 'StaticBlock') {
+
+            }
+        }
+
+        this.indentacao -= 4;
+        resultado += ' '.repeat(this.indentacao) + '}\n';
+        return resultado;
+    }
+
+    traduzirDeclaracaoRetorna(declaracao: ReturnStatement): string {
+        return `retorna ${this.dicionarioConstrutos[declaracao.argument.type](declaracao.argument)}`;
+    }
+
+    traduzirDeclaracaoEnquanto(declaracao: WhileStatement): string{
+        let resultado = 'enquanto(';
+        resultado += this.dicionarioConstrutos[declaracao.test.type](declaracao.test);
+        resultado += ')';
+        resultado += this.logicaComumBlocoEscopo(declaracao);
+        return resultado;
+    }
 
-        console.log(declaracao);
-        return '';
+    traduzirDeclaracaoFazerEnquanto(declaracao: DoWhileStatement): string {
+        let resultado = 'fazer'
+        resultado += this.logicaComumBlocoEscopo(declaracao);
+        resultado += 'enquanto('
+        resultado += this.dicionarioConstrutos[declaracao.test.type](declaracao.test)
+        resultado += ')'
+        return resultado;
+    }
+
+    traduzirDeclaracaoSe(declaracao: IfStatement): string {
+        let resultado = 'if (';
+        resultado += this.dicionarioConstrutos[declaracao.test.type](declaracao.test)
+        resultado += ')'
+        resultado += this.logicaComumBlocoEscopo(declaracao.consequent)
+        if(declaracao?.alternate){
+            resultado += 'else '
+            if(declaracao.alternate.constructor.name === 'BlockStatement'){
+                resultado += this.logicaComumBlocoEscopo(declaracao.consequent);
+                return resultado;
+            }
+            resultado += this.traduzirDeclaracao(declaracao.alternate)
+            return resultado;
+        }
+        return resultado;
+    }
+
+    traduzirDeclaracaoTente(declaracao: TryStatement): string {
+        let resultado = 'tente '
+
+        resultado += this.logicaComumBlocoEscopo(declaracao.block);
+
+        if(declaracao.handler){
+            resultado += 'pegue'
+            if(declaracao.handler.param){
+                const identificador = declaracao.handler.param as Identifier;
+                resultado += `(${identificador.name})`
+            }
+            resultado += this.logicaComumBlocoEscopo(declaracao.block);
+        }
+        if(declaracao.finalizer){
+            resultado += 'finalmente'
+            resultado += this.logicaComumBlocoEscopo(declaracao.finalizer);
+        }
+
+        return resultado;
     }
 
     traduzirDeclaracao(declaracao: any): string {
         switch (declaracao.type) {
             case 'ClassDeclaration':
-                return this.traduzirClasseDeclaracao(declaracao);
+                return this.traduzirDeclaracaoClasse(declaracao);
+            case 'DoWhileStatement':
+                return this.traduzirDeclaracaoFazerEnquanto(declaracao)
             case 'ExpressionStatement':
                 return this.traduzirExpressaoDeclaracao(declaracao);
+            case 'ForStatement':
+                return this.traduzirDeclaracaoPara(declaracao);            
             case 'FunctionDeclaration':
-                return this.traduzirDeclaracaoDeFuncao(declaracao);
+                return this.traduzirDeclaracaoFuncao(declaracao);
+            case 'IfStatement':
+                return this.traduzirDeclaracaoSe(declaracao);
+            case 'ReturnStatement':
+                return this.traduzirDeclaracaoRetorna(declaracao);
+            case 'TryStatement':
+                return this.traduzirDeclaracaoTente(declaracao);
             case 'VariableDeclaration':
-                return this.traduzirDeclaracaoDeVariavel(declaracao);
+                return this.traduzirDeclaracaoVariavel(declaracao);
+            case 'WhileStatement':
+                return this.traduzirDeclaracaoEnquanto(declaracao);
         }
     }
 
@@ -143,12 +353,7 @@ export class TradutorReversoJavaScript {
         for (let declaracao of declaracoes.body) {
             resultado += `${this.traduzirDeclaracao(declaracao)} \n`;
         }
-        console.log(resultado);
+
         return resultado;
     }
-}
-
-//cd ./fontes/tradutores
-//ts-node -T tradutor-reverso-javascript.ts
-// var tjs = new TradutorReversoJavaScript();
-// tjs.traduzir();
+}
\ No newline at end of file


Test patch:
diff --git a/testes/tradutores/tradutor-reverso-javascript.test.ts b/testes/tradutores/tradutor-reverso-javascript.test.ts
index f287ec72..8206f3ae 100644
--- a/testes/tradutores/tradutor-reverso-javascript.test.ts
+++ b/testes/tradutores/tradutor-reverso-javascript.test.ts
@@ -29,6 +29,29 @@ describe('Tradutor Reverso JavaScript -> Delégua', () => {
             expect(resultado).toMatch(/escreva\('Oi'\)/i);
         });
 
+        it('for -> para', () => {
+            const codigo = 'for (let i = 0; i < 10; i++) { console.log(i) }'
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/para \(var i = 0; i < 10; i\+\+\)/i);
+            expect(resultado).toMatch(/escreva\(i\)/i);
+        });
+
+        it('array - vetor - com valores', () => {
+            const codigo = 'let vetor = [1, \'2\']'
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var vetor = \[1, \'2\'\]/i);
+        });
+
+        it('array - vetor - vazio', () => {
+            const codigo = 'let vetor = []'
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var vetor = \[\]/i);
+        });
+
         it('const/let/var -> var', () => {
             const codigo = `const a = 1\nlet b = 2\nvar c = 3`;
 
@@ -58,23 +81,181 @@ describe('Tradutor Reverso JavaScript -> Delégua', () => {
             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);
-        // });
+        it('function -> funcao com retorno vazio', () => {
+            const codigo = `function teste(a, b, c) { return '' }`;
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/retorna \'\'/i);
+        });
+
+        it('function -> funcao com retorno vazio', () => {
+            const codigo = `function teste(a, b, c) { return 0 }`;
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/retorna 0/i);
+        });
+
+        it('function -> funcao com retorno de variavel', () => {
+            const codigo = `function teste(a, b, c) { return a }`;
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/retorna a/i);
+        });
+
+        it('function -> funcao com retorno de soma valores', () => {
+            const codigo = `function teste(a, b, c) { return 1 + 2 }`;
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/retorna 1 \+ 2/i);
+        });
+
+        it('function -> chamada de função', () => {
+            const codigo = `function teste(a, b, c) {console.log(\'Oi\')} teste(1,2,3)`;
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/funcao teste\(a, b, c\)/i);
+            expect(resultado).toMatch(/escreva\('Oi'\)/i);
+            expect(resultado).toMatch(/teste\(1, 2, 3\)/i);
+        });
+
+        it('class -> classe', () => {
+            const codigo = `
+                class Base {
+                    constructor(){}
+                }
+                class Rectangle extends Base {
+                    constructor(height, width, abc) {
+                        this.height = height;
+                        this.width = width;
+                    }
+
+                    teste(){
+                        console.log('oi')
+                    }
+
+                    teste2(parametro1){
+                        console.log('oi')
+                    }
+                }
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+        });
+
+        it('class -> classe', () => {
+            const codigo = `
+                class Base {
+                }
+                class Retangulo extends Base {
+                    constructor(a,b,c){
+                    }
+                }
+                var retangulo = new Retangulo(1,2,'a')
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+        });
+
+        it('while -> enquanto', () => {
+            const codigo = `
+                let i = 0;
+                while(i < 10){
+                    escreva(i)
+                    i++;
+                }
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var i = 0/i);
+            expect(resultado).toMatch(/enquanto\(i < 10\){/i);
+        });
+
+        it('do while -> fazer enquanto', () => {
+            const codigo = `
+                let result = '';
+                let i = 0;
+                
+                do {
+                i = i + 1;
+                result = result + i;
+                } while (i < 5);
+                
+                console.log(result);
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/fazer{/i);
+            expect(resultado).toMatch(/enquanto\(i < 5\)/i);
+        });
+
+        it('if -> se', () => {
+            const codigo = `
+                let i = 1;                
+                if(i == 1){
+                    console.log(\'i é igual a 1\')
+                }
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var i = 1/i);
+            expect(resultado).toMatch(/if \(i == 1\)/i);
+        });
+
+        it('if/else if/else -> se/senao se/senao', () => {
+            const codigo = `
+                let i = 1;                
+                if(i == 1){
+                    console.log(\'i é igual a 1\')
+                } 
+                else if(i === 2){
+                    console.log(\'i é igual a 2\')
+                } 
+                else{
+                    console.log(\'i não é igual a 1 e nem igual a 2\')
+                }
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/var i = 1/i);
+            expect(resultado).toMatch(/if \(i == 1\)/i);
+            expect(resultado).toMatch(/else if \(i == 2\)/i);
+            expect(resultado).toMatch(/else {/i);
+        });
+
+        it('try/catch/finally -> tente/pegue/finalmente', () => {
+            const codigo = `                
+                try {
+                    console.log(\'Teste1\')
+                } catch (erro){
+                    console.log(erro)
+                } finally {
+                    console.log(\'Terminou\')
+                }
+            `
+
+            const resultado = tradutor.traduzir(codigo);
+            expect(resultado).toBeTruthy();
+            expect(resultado).toMatch(/tente/i);
+            expect(resultado).toMatch(/pegue\(erro\)/i);
+            expect(resultado).toMatch(/finalmente/i);
+            expect(resultado).toMatch(/escreva\('Teste1'\)/i);
+            // expect(resultado).toMatch(/escreva\(erro\)/i);
+            expect(resultado).toMatch(/escreva\('Terminou'\)/i);
+        });
     });
 });