Repository: DesignLiquido/delegua
Pull request #457 (2023-06-20 13:57:27)

Fizzbuzz birl


Patch:
diff --git a/.vscode/settings.json b/.vscode/settings.json
index a43b6db0..5d41b3ad 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -19,5 +19,6 @@
         "titleBar.inactiveBackground": "#00000099",
         "titleBar.inactiveForeground": "#e7e7e799"
     },
-    "peacock.color": "#000000"
+    "peacock.color": "#000000",
+    "compile-hero.disable-compile-files-on-did-save-code": true
 }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
index e024d855..15816bf3 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
@@ -33,7 +33,6 @@ import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
 
 import { Construto } from '../../construtos/construto';
 import { ParametroInterface, SimboloInterface } from '../../interfaces';
-import { TiposDadosInterface } from '../../interfaces/tipos-dados-interface';
 import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
 
 export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
@@ -219,10 +218,10 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.'
         );
 
-        let declaracaoInicial: Var | Expressao | null = null;
+        let declaracaoInicial: Variavel | Expressao | null | any[] = null;
 
         if (this.simbolos[this.atual].tipo === tiposDeSimbolos.IDENTIFICADOR) {
-            this.consumir(
+            const variavelLoop = this.consumir(
                 tiposDeSimbolos.IDENTIFICADOR,
                 'Esperado expressão `IDENTIFICADOR` após `(` para iniciar o bloco `PARA`.'
             );
@@ -234,11 +233,10 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.NUMERO,
                 'Esperado expressão `NUMERO` após `=` para iniciar o bloco `PARA`.'
             );
-            declaracaoInicial = new Var(
-                this.simbolos[this.atual],
-                new Literal(this.simbolos[this.atual].linha, this.hashArquivo, valor.literal),
-                'numero'
-            );
+            declaracaoInicial = [
+                new Variavel(this.hashArquivo, variavelLoop),
+                new Literal(this.hashArquivo, Number(valor.linha), Number(valor.literal)),
+            ];
         } else {
             const declaracaoVetor = this.declaracao(); // inicialização da variável de controle
             if (Array.isArray(declaracaoVetor)) {
@@ -285,8 +283,6 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         throw new Error('Método não implementado.');
     }
 
-
-
     declaracaoEscreva(): Escreva {
         const primeiroSimbolo = this.consumir(tiposDeSimbolos.CE, 'Esperado expressão `CE` para escrever mensagem.');
         this.consumir(tiposDeSimbolos.QUER, 'Esperado expressão `QUER` após `CE` para escrever mensagem.');
@@ -302,12 +298,11 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
 
         argumentos.push(this.declaracao());
 
-        while(!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)) {
                 const variavelParaEscrita = this.declaracao();
                 argumentos.push(variavelParaEscrita);
             }
-
         }
 
         this.consumir(
@@ -558,75 +553,109 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         ]);
     }
 
-    declaracaoSe(): Se {
-        const simboloSe: SimboloInterface = this.consumir(
-            tiposDeSimbolos.ELE,
-            'Esperado expressão `ELE` para condição.'
-        );
-        this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` após `ELE` para condição.');
-        this.consumir(tiposDeSimbolos.A, 'Esperado expressão `A` após `QUE` para condição.');
-        this.consumir(tiposDeSimbolos.GENTE, 'Esperado expressão `GENTE` após `A` para condição.');
-        this.consumir(tiposDeSimbolos.QUER, 'Esperado expressão `QUER` após `GENTE` para condição.');
-        this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `QUER` para condição.');
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            'Esperado parêntese esquerdo após interrogação para condição.'
-        );
+    protected consomeSeSenao() {
+        this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` após `SE`.');
+        this.consumir(tiposDeSimbolos.NAO, 'Esperado expressão `NAO` após `QUE`.');
+        this.consumir(tiposDeSimbolos.VAI, 'Esperado expressão `VAI` após `NAO`.');
+        this.consumir(tiposDeSimbolos.DAR, 'Esperado expressão `DAR` após `VAI`.');
+        this.consumir(tiposDeSimbolos.O, 'Esperado expressão `O` após `DAR`.');
+        this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` após `O`.');
+        this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado expressão `?` após `QUE`.');
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `?`.');
+        const condicaoSeSenao = this.declaracao();
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após expressão de condição.');
+
+        return {
+            condicaoSeSenao,
+        };
+    }
 
-        const condicao = this.declaracao();
+    protected consomeSe() {
+        const simboloSe: SimboloInterface = this.consumir(tiposDeSimbolos.ELE, 'Esperado expressão `ELE`.');
+        this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` após `ELE`.');
+        this.consumir(tiposDeSimbolos.A, 'Esperado expressão `A` após `QUE`.');
+        this.consumir(tiposDeSimbolos.GENTE, 'Esperado expressão `GENTE` após `A`.');
+        this.consumir(tiposDeSimbolos.QUER, 'Esperado expressão `QUER` após `GENTE`.');
+        this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado expressão `?` após `QUER`.');
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `?`.');
+        const condicaoSe = this.declaracao();
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após expressão de condição.');
 
-        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após condição.');
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            'Esperado quebra de linha após expressão de condição para condição.'
-        );
-        const declaracoes = [];
-        while (this.verificarTipoSimboloAtual(tiposDeSimbolos.QUEBRA_LINHA)) {
-            this.consumir(tiposDeSimbolos.QUEBRA_LINHA, '');
+        return {
+            simboloSe,
+            condicaoSe,
+        };
+    }
+
+    consumeSenao() {
+        this.consumir(tiposDeSimbolos.NAO, 'Esperado expressão `NAO` após `SE`.');
+        this.consumir(tiposDeSimbolos.VAI, 'Esperado expressão `VAI` após `NAO`.');
+        this.consumir(tiposDeSimbolos.DAR, 'Esperado expressão `DAR` após `VAI`.');
+        this.consumir(tiposDeSimbolos.NAO, 'Esperado expressão `NAO` após `DAR`.');
+    }
+
+    resolveCaminhoSe() {
+        let controle: boolean = true;
+        const declaracoesEntao = [];
+        while (controle) {
+            switch (this.simbolos[this.atual].tipo) {
+                case tiposDeSimbolos.BIRL:
+                case tiposDeSimbolos.NAO:
+                    controle = false;
+                    break;
+                case tiposDeSimbolos.QUE:
+                    if (this.verificarTipoProximoSimbolo(tiposDeSimbolos.NAO)) {
+                        controle = false;
+                        break;
+                    }
+                default:
+                    declaracoesEntao.push(this.declaracao());
+            }
         }
-        let caminhoSenao = null;
-        do {
-            declaracoes.push(this.declaracao());
 
-            if (this.verificarTipoSimboloAtual(tiposDeSimbolos.NAO)) {
-                const simboloSenao: SimboloInterface = this.consumir(
-                    tiposDeSimbolos.NAO,
-                    'Esperado expressão `NAO` após expressão de condição.'
-                );
-                this.consumir(tiposDeSimbolos.VAI, 'Esperado expressão `VAI` após `NAO`.');
-                this.consumir(tiposDeSimbolos.DAR, 'Esperado expressão `DAR` após `VAI`.');
-                this.consumir(tiposDeSimbolos.NAO, 'Esperado expressão `NAO` após `DAR`.');
+        return new Bloco(
+            this.hashArquivo,
+            Number(this.simbolos[this.atual].linha),
+            declaracoesEntao.filter((d) => d)
+        );
+    }
 
-                const declaracaoSenao = [];
+    declaracaoSe(): Se {
+        const { condicaoSe, simboloSe } = this.consomeSe();
 
-                do {
-                    declaracaoSenao.push(this.declaracao());
-                } while (![tiposDeSimbolos.BIRL].includes(this.simbolos[this.atual].tipo));
+        const caminhoEntão = this.resolveCaminhoSe();
 
-                caminhoSenao = new Bloco(
-                    this.hashArquivo,
-                    Number(simboloSe.linha),
-                    declaracaoSenao.filter((d) => d)
-                );
-                break;
-            }
-        } while (![tiposDeSimbolos.BIRL].includes(this.simbolos[this.atual].tipo));
+        const caminhoSeSenao = [];
 
-        this.consumir(tiposDeSimbolos.BIRL, 'Esperado expressão `BIRL` após expressão de condição.');
+        while (
+            !this.verificarTipoSimboloAtual(tiposDeSimbolos.BIRL) &&
+            !this.verificarTipoSimboloAtual(tiposDeSimbolos.NAO)
+        ) {
+            const { condicaoSeSenao } = this.consomeSeSenao();
 
-        return new Se(
-            condicao,
-            new Bloco(
-                this.hashArquivo,
-                Number(simboloSe.linha),
-                declaracoes.filter((d) => d)
-            ),
-            [],
-            caminhoSenao
-        );
+            const caminho = this.resolveCaminhoSe();
+
+            caminhoSeSenao.push({
+                condicao: condicaoSeSenao,
+                caminho: caminho,
+            });
+        }
+
+        let caminhoSenao = null;
+
+        if (this.verificarTipoSimboloAtual(tiposDeSimbolos.NAO)) {
+            this.consumeSenao();
+            const declaraçõesSenao = [];
+            while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.BIRL)) {
+                declaraçõesSenao.push(this.declaracao());
+            }
+            caminhoSenao = new Bloco(this.hashArquivo, Number(this.simbolos[this.atual].linha), declaraçõesSenao.filter((d) => d));
+        }
+
+        return new Se(condicaoSe, caminhoEntão, caminhoSeSenao, caminhoSenao);
     }
 
-    resolveSimboloInterfaceParaTiposDadosInterface(simbolo: SimboloInterface): TiposDadosInterface {
+    resolveSimboloInterfaceParaTiposDadosInterface(simbolo: SimboloInterface) {
         switch (simbolo.tipo) {
             case tiposDeSimbolos.TRAPEZIO:
                 this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DESCENDENTE);
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index 30410a2d..cae085d5 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -82,46 +82,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         throw new Error("Método não implementado.");
     }
 
-    declaracaoDeVariavel(): Var {
+    declaracaoDeVariaveis(): Var[] {
         throw new Error("Método não implementado.");
     }
 
-    declaracaoDeVariaveis(): any {
-        const identificadores: SimboloInterface[] = [];
-        let retorno: Declaracao[] = [];
-
-        do {
-            identificadores.push(this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-            for (let [indice, identificador] of identificadores.entries()) {
-                retorno.push(new Var(identificador, null));
-            }
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-            return retorno;
-        }
-
-        //this.consumir(tiposDeSimbolos.IGUAL, "Esperado '=' após identificador em instrução 'var'.");
-
-        const inicializadores = [];
-        do {
-            inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        if (identificadores.length !== inicializadores.length) {
-            throw this.erro(this.simboloAtual(), "Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.");
-        }
-
-        for (let [indice, identificador] of identificadores.entries()) {
-            retorno.push(new Var(identificador, inicializadores[indice]));
-        }
-
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-
-        return retorno;
-    }
-
     sincronizar(): void {
         this.avancarEDevolverAnterior();
 
@@ -553,7 +517,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     blocoEscopo(): any[] {
-        let declaracoes: Array<RetornoDeclaracao> = [];
+        const declaracoes = [];
         let simboloAtual = this.simboloAtual();
         const simboloAnterior = this.simboloAnterior();
 
@@ -587,13 +551,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                 // Significa que o código acabou, então o bloco também acabou.
                 const espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
                 while (espacosIndentacaoLinhaAtual === espacosIndentacaoBloco) {
-                    const retornoDeclaracao = this.declaracao();
-                    if (Array.isArray(retornoDeclaracao)) {
-                        declaracoes = declaracoes.concat(retornoDeclaracao);
-                    } else {
-                        declaracoes.push(retornoDeclaracao as Declaracao);
-                    }
-                    
+                    declaracoes.push(this.declaracao());
                     simboloAtual = this.simboloAtual();
                     if (!simboloAtual) break;
                     espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
@@ -693,7 +651,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 inicializador = null;
             } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) {
-                inicializador = this.declaracaoDeVariaveis();
+                inicializador = this.declaracaoDeVariavel();
             } else {
                 inicializador = this.declaracaoExpressao();
             }
@@ -879,6 +837,19 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         return this.declaracaoExpressao();
     }
 
+    declaracaoDeVariavel(): Var {
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.');
+        let inicializador = null;
+        if (
+            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL) ||
+            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MAIS_IGUAL)
+        ) {
+            inicializador = this.expressao();
+        }
+
+        return new Var(simbolo, inicializador);
+    }
+
     funcao(tipo: string, construtor?: boolean): FuncaoDeclaracao {
         const simbolo: SimboloInterface = !construtor
             ? this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`)
@@ -974,7 +945,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                 this.avancarEDevolverAnterior();
                 return this.funcao('funcao');
             }
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) return this.declaracaoDeVariaveis();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) return this.declaracaoDeVariavel();
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE)) return this.declaracaoDeClasse();
 
             return this.resolverDeclaracao();
@@ -995,14 +966,9 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         this.simbolos = retornoLexador?.simbolos || [];
         this.pragmas = retornoLexador?.pragmas || {};
 
-        let declaracoes: Declaracao[] = [];
+        const declaracoes: Declaracao[] = [];
         while (!this.estaNoFinal()) {
-            const retornoDeclaracao = this.declaracao();
-            if (Array.isArray(retornoDeclaracao)) {
-                declaracoes = declaracoes.concat(retornoDeclaracao);
-            } else {
-                declaracoes.push(retornoDeclaracao as Declaracao);
-            }
+            declaracoes.push(this.declaracao() as Declaracao);
         }
 
         if (this.performance) {
diff --git a/fontes/interpretador/dialetos/birl/interpretador-birl.ts b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
index f2c7d7a7..374aaace 100644
--- a/fontes/interpretador/dialetos/birl/interpretador-birl.ts
+++ b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
@@ -4,6 +4,7 @@ import {
     FimPara,
     FormatacaoEscrita,
     Literal,
+    Logico,
     Super,
     TipoDe,
     Unario,
@@ -548,12 +549,44 @@ export class InterpretadorBirl implements InterpretadorInterface {
         }
     }
 
-    visitarExpressaoLogica(expressao: any) {
-        throw new Error('Método não implementado.');
+    async visitarExpressaoLogica(expressao: Logico): Promise<any> {
+        const esquerda = await this.avaliar(expressao.esquerda);
+
+        if (expressao.operador.tipo === tiposDeSimbolos.EM) {
+            const direita = await this.avaliar(expressao.direita);
+
+            if (Array.isArray(direita) || typeof direita === 'string') {
+                return direita.includes(esquerda);
+            } else if (direita.constructor === Object) {
+                return esquerda in direita;
+            } else {
+                throw new ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
+            }
+        }
+
+        // se um estado for verdadeiro, retorna verdadeiro
+        if (expressao.operador.tipo === tiposDeSimbolos.OU) {
+            if (this.eVerdadeiro(esquerda)) return esquerda;
+        }
+
+        // se um estado for falso, retorna falso
+        if (expressao.operador.tipo === tiposDeSimbolos.E) {
+            if (!this.eVerdadeiro(esquerda)) return esquerda;
+        }
+
+        return await this.avaliar(expressao.direita);
     }
+
     async visitarDeclaracaoPara(declaracao: Para): Promise<any> {
         if (declaracao.inicializador !== null) {
-            await this.avaliar(declaracao.inicializador);
+            if (declaracao.inicializador instanceof Array) {
+                if (declaracao.inicializador[0] instanceof Variavel) {
+                    const valor = await this.avaliar(declaracao.inicializador[1]);
+                    this.pilhaEscoposExecucao.atribuirVariavel(declaracao.inicializador[0].simbolo, valor);
+                }
+            } else {
+                await this.avaliar(declaracao.inicializador);
+            }
         }
 
         let retornoExecucao: any;
diff --git a/fontes/lexador/dialetos/lexador-birl.ts b/fontes/lexador/dialetos/lexador-birl.ts
index 8df8d66c..90fec5ae 100644
--- a/fontes/lexador/dialetos/lexador-birl.ts
+++ b/fontes/lexador/dialetos/lexador-birl.ts
@@ -118,6 +118,12 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
 
                 break;
             case '&':
+                if (this.proximoSimbolo() === '&') {
+                    this.avancar();
+                    this.avancar();
+                    this.adicionarSimbolo(tiposDeSimbolos.E);
+                    break;
+                }
                 // Ler o simbolo porem não é tratado.
                 this.adicionarSimbolo(tiposDeSimbolos.PONTEIRO);
                 this.avancar();
diff --git a/fontes/tipos-de-simbolos/birl.ts b/fontes/tipos-de-simbolos/birl.ts
index 89351c34..9f9ba924 100644
--- a/fontes/tipos-de-simbolos/birl.ts
+++ b/fontes/tipos-de-simbolos/birl.ts
@@ -23,7 +23,9 @@ export default {
     DIVISAO_INTEIRA_IGUAL: 'DIVISAO_INTEIRA_IGUAL',
     DESCENDENTE: 'DESCENDENTE',
     DECREMENTAR: 'DECREMENTAR',
+    E: 'E',
     ELE: 'ELE',
+    EM: 'EM',
     ESSA: 'ESSA',
     EXPONENCIACAO:'EXPONENCIACAO',
     FRANGAO: 'FRANGAO',
@@ -50,6 +52,7 @@ export default {
     NEGATIVA: 'NEGATIVA',
     NEGACAO: 'NEGACAO',
     O: 'O',
+    OU: 'OU',
     OH: 'OH',
     PO: 'PO',
     PORRA: 'PORRA',


Test patch:
diff --git a/testes/birl/interpretador.test.ts b/testes/birl/interpretador.test.ts
index d5d49c07..cbd5fd80 100644
--- a/testes/birl/interpretador.test.ts
+++ b/testes/birl/interpretador.test.ts
@@ -15,14 +15,24 @@ describe('Interpretador', () => {
                 interpretador = new InterpretadorBirl(process.cwd());
             });
 
-            it('Sucesso - declaração - escreva com variavel', async () => {
+            it('Sucesso - fizzbuzz', async () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW\n',
-                    '   FRANGO X = "testeeeeeeeeeeeeeeeeeeeeee";\n',
-                    '   CE QUER VER ESSA PORRA? ("A variavel X tem valor: %s\n", X);\n',
-                    '   BORA CUMPADE 0;\n',
+                    '    MONSTRO M;\n',
+                    '    MAIS QUERO MAIS (M = 1; M <= 100; M++)\n',
+                    '        ELE QUE A GENTE QUER? (M % 5 == 0 && M % 3 == 0)\n',
+                    '            CE QUER VER ESSA PORRA?("FizzBuzz\n");\n',
+                    '        QUE NAO VAI DAR O QUE? (M % 3 == 0)\n',
+                    '            CE QUER VER ESSA PORRA?("Fizz\n");\n',
+                    '        QUE NAO VAI DAR O QUE? (M % 5 == 0)\n',
+                    '            CE QUER VER ESSA PORRA?("Buzz\n");\n',
+                    '        NAO VAI DAR NAO\n',
+                    '            CE QUER VER ESSA PORRA?("%d\n", M);\n',
+                    '        BIRL\n',
+                    '    BIRL\n',
+                    '    BORA CUMPADE 0;\n',
                     'BIRL\n',
-                ])
+                ]);
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
@@ -30,7 +40,7 @@ describe('Interpretador', () => {
 
                 expect(retornoInterpretador).toBeTruthy();
                 expect(retornoInterpretador.erros).toHaveLength(0);
-            })
+            });
 
             it('Sucesso - declaração - chamarFuncao', async () => {
                 const retornoLexador = lexador.mapear([
diff --git a/testes/egua-classico/interpretador.test.ts b/testes/egua-classico/interpretador.test.ts
index 6e72e8e7..a8311289 100644
--- a/testes/egua-classico/interpretador.test.ts
+++ b/testes/egua-classico/interpretador.test.ts
@@ -142,6 +142,18 @@ describe('Interpretador (Égua Clássico)', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+                it('Condicionais - senão se', async () => {
+                    const retornoLexador = lexador.mapear(
+                        ['var a = 1;', 'se (a > 2) { escreva("Nunca acontece"); } senão se (a == 1) { escreva("Um é igual a um"); } senão { escreva("Nunca acontece"); }']
+                    )
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1)
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes)
+
+                    expect(retornoInterpretador.erros).toHaveLength(0)
+                })
             });
 
             describe('Laços de repetição', () => {
diff --git a/testes/eguap/interpretador.test.ts b/testes/eguap/interpretador.test.ts
index bbb6cb19..dab7c47d 100644
--- a/testes/eguap/interpretador.test.ts
+++ b/testes/eguap/interpretador.test.ts
@@ -17,10 +17,7 @@ describe('Interpretador (EguaP)', () => {
         describe('Cenários de sucesso', () => {
             describe('Atribuições', () => {
                 it('Trivial', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = 1",
-                        "var b, c = 1, 2"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(["var a = 1;"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -157,6 +154,8 @@ describe('Interpretador (EguaP)', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+
             });
 
             describe('Laços de repetição', () => {