Repository: DesignLiquido/delegua
Pull request #666 (2024-02-25 00:23:32)

Método `filtrarPor` não filtra vetor
Resolve: https://github.com/DesignLiquido/delegua/issues/664

- [X] Biblioteca global
- [ ] Primitiva vetor


Patch:
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index a0cad4ee..602a3340 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -435,6 +435,13 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
     }
 
     visitarDeclaracaoEscreva(declaracao: Escreva) {
+        if (declaracao.argumentos.length === 0) {
+            const { linha, hashArquivo } = declaracao;
+            const simbolo: SimboloInterface<''> = { literal: '', tipo:'', lexema: 'escreva', linha, hashArquivo }
+            this.erro(simbolo, `É preciso ter um ou mais parametros para 'escreva(...)'`);
+            return Promise.resolve();
+        }
+
         const variaveis = declaracao.argumentos.filter((arg) => arg instanceof Variavel);
 
         for (let variavel of variaveis as Variavel[]) {
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index a4838b98..de99d509 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -622,9 +622,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
 
         const argumentos: Construto[] = [];
 
-        do {
-            argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+            do {
+                argumentos.push(this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+        }
+
 
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
diff --git a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
index d3a3abe7..74551cac 100644
--- a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
+++ b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
@@ -60,8 +60,8 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
 
     tiposPotigolParaDelegua = {
         Caractere: 'texto',
-        Inteiro: 'numero',
-        Logico: 'lógico',
+        Inteiro: 'inteiro',
+        Logico: 'logico',
         Lógico: 'lógico',
         Real: 'numero',
         Texto: 'texto',
@@ -169,8 +169,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
                 this.simbolos[this.atual],
                 'Esperado tipo válido após dois-pontos como retorno de função.'
             );
-
-            tipoRetorno = this.simbolos[this.atual - 1];
+            tipoRetorno = this.simbolos[this.atual];
         }
 
         // Se houver símbolo de igual, seja após fechamento de parênteses,
@@ -984,10 +983,10 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
             simboloTipo.linha,
             propriedades.map(
                 (p) =>
-                    ({
-                        abrangencia: 'padrao',
-                        nome: p.nome,
-                    } as ParametroInterface)
+                ({
+                    abrangencia: 'padrao',
+                    nome: p.nome,
+                } as ParametroInterface)
             ),
             instrucoesConstrutor
         );
diff --git a/fontes/bibliotecas/biblioteca-global.ts b/fontes/bibliotecas/biblioteca-global.ts
index 544faaec..549af082 100644
--- a/fontes/bibliotecas/biblioteca-global.ts
+++ b/fontes/bibliotecas/biblioteca-global.ts
@@ -406,9 +406,9 @@ export default function (interpretador: VisitanteComumInterface, pilhaEscoposExe
             const resultados = [];
             for (let indice = 0; indice < valorVetor.length; ++indice) {
                 const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
-                if (deveRetornarValor) {
-                    resultados.push(valorVetor[indice]);
-                }
+                if (deveRetornarValor === false) continue;
+                
+                resultados.push(valorVetor[indice]);
             }
 
             return resultados;
diff --git a/fontes/formatadores/formatador-potigol.ts b/fontes/formatadores/formatador-potigol.ts
new file mode 100644
index 00000000..2adc0831
--- /dev/null
+++ b/fontes/formatadores/formatador-potigol.ts
@@ -0,0 +1,779 @@
+import {
+    AcessoIndiceVariavel,
+    AcessoMetodoOuPropriedade,
+    Agrupamento,
+    AtribuicaoPorIndice,
+    Atribuir,
+    Binario,
+    Chamada,
+    Constante,
+    Construto,
+    Deceto,
+    DefinirValor,
+    Dicionario,
+    Dupla,
+    ExpressaoRegular,
+    FimPara,
+    FormatacaoEscrita,
+    FuncaoConstruto,
+    Isto,
+    Literal,
+    Logico,
+    Noneto,
+    Octeto,
+    Quarteto,
+    Quinteto,
+    Septeto,
+    Sexteto,
+    Super,
+    TipoDe,
+    Trio,
+    Tupla,
+    Unario,
+    Variavel,
+    Vetor,
+} from '../construtos';
+import {
+    Classe,
+    Const,
+    ConstMultiplo,
+    Expressao,
+    FuncaoDeclaracao,
+    Enquanto,
+    Escolha,
+    Escreva,
+    Fazer,
+    Importar,
+    Para,
+    ParaCada,
+    Se,
+    Tente,
+    Var,
+    VarMultiplo,
+    Bloco,
+    Continua,
+    EscrevaMesmaLinha,
+    Leia,
+    LeiaMultiplo,
+    Retorna,
+    Sustar,
+    Declaracao,
+    Falhar,
+    Aleatorio,
+    CabecalhoPrograma,
+    TendoComo,
+    PropriedadeClasse,
+} from '../declaracoes';
+import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
+import { VisitanteComumInterface } from '../interfaces';
+import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
+import tiposDeSimbolos from '../tipos-de-simbolos/potigol';
+import { inferirTipoVariavel } from '../interpretador/inferenciador';
+export class FormatadorPotigol implements VisitanteComumInterface {
+    indentacaoAtual: number;
+    quebraLinha: string;
+    tamanhoIndentacao: number;
+    codigoFormatado: string;
+    devePularLinha: boolean;
+    deveIndentar: boolean;
+
+    constructor(quebraLinha: string, tamanhoIndentacao: number = 4) {
+        this.quebraLinha = quebraLinha;
+        this.tamanhoIndentacao = tamanhoIndentacao;
+
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = '';
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+    }
+
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): void | Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
+    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
+    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
+    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoClasse(declaracao: Classe) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}tipo ${declaracao.simbolo.lexema}${this.quebraLinha}`
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.propriedades)
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.metodos)
+        this.codigoFormatado += `fim${this.quebraLinha}`
+    }
+
+    visitarExpressaoPropriedadeClasse(expressao: PropriedadeClasse): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}${expressao.nome.lexema}: `
+        if (expressao.tipo) {
+            this.codigoFormatado += `${expressao.tipo}`
+        }
+        this.codigoFormatado += this.quebraLinha
+    }
+
+    visitarDeclaracaoConst(declaracao: Const): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}${declaracao.simbolo.lexema}`
+
+        if (declaracao.tipo) {
+            this.codigoFormatado += ": "
+            switch (declaracao.tipo.toUpperCase()) {
+                case tiposDeSimbolos.TEXTO:
+                    this.codigoFormatado += 'Caractere = '
+                    break;
+                case tiposDeSimbolos.INTEIRO:
+                    this.codigoFormatado += 'Inteiro = '
+                    break;
+                case "NUMERO":
+                case tiposDeSimbolos.REAL:
+                    this.codigoFormatado += 'Real = '
+                    break;
+                case tiposDeSimbolos.LOGICO:
+                    this.codigoFormatado += 'Logico = '
+                    break;
+                case tiposDeSimbolos.LÓGICO:
+                    this.codigoFormatado += 'Lógico = '
+                    break;
+                default:
+                    console.log(declaracao.tipo);
+                    break;
+            }
+        }
+
+        if (declaracao.inicializador && !declaracao.tipo) {
+            this.codigoFormatado += " = "
+        }
+
+        if (declaracao.inicializador) {
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador)
+        }
+
+    }
+    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeAtribuicao(expressao: Atribuir) {
+        this.codigoFormatado += `${expressao.simbolo.lexema} de `;
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += `${this.quebraLinha}`;
+        }
+    }
+
+    visitarDeclaracaoDeExpressao(declaracao: Expressao) {
+        this.formatarDeclaracaoOuConstruto(declaracao.expressao)
+    }
+
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
+        if (declaracao.simbolo.tipo !== tiposDeSimbolos.CONSTRUTOR) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${declaracao.simbolo.lexema}(`;
+
+            this.visitarExpressaoFuncaoConstruto(declaracao.funcao);
+        }
+    }
+
+    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}enquanto(`;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) faca`;
+        this.codigoFormatado += this.quebraLinha;
+
+        this.devePularLinha = true
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+        this.codigoFormatado += this.quebraLinha;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}fim`;
+        this.devePularLinha = false
+    }
+
+    private formatarBlocoOuVetorDeclaracoes(declaracoes: Declaracao[]) {
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+    }
+
+
+    visitarDeclaracaoEscolha(declaracao: Escolha) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escolha `;
+
+        this.formatarDeclaracaoOuConstruto(declaracao.identificadorOuLiteral);
+        this.indentacaoAtual += this.tamanhoIndentacao;
+
+        for (let caminho of declaracao.caminhos) {
+            this.deveIndentar = false
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}caso `;
+            this.formatarBlocoOuVetorDeclaracoes(caminho.condicoes)
+            this.codigoFormatado += ` => `;
+            this.formatarBlocoOuVetorDeclaracoes(caminho.declaracoes)
+            this.codigoFormatado += this.quebraLinha
+            this.deveIndentar = true
+        }
+
+        if (declaracao.caminhoPadrao.declaracoes.length > 0) {
+            this.deveIndentar = false
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}caso _ => `;
+            this.formatarBlocoOuVetorDeclaracoes(declaracao.caminhoPadrao.declaracoes);
+            this.deveIndentar = true
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+
+    visitarDeclaracaoEscreva(declaracao: Escreva) {
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escreva (`;
+        } else {
+            this.codigoFormatado += `escreva (`;
+        }
+        for (let argumento of declaracao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+        }
+
+        this.codigoFormatado += `)`
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha
+        }
+    }
+
+    visitarDeclaracaoFazer(declaracao: Fazer) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoImportar(declaracao: Importar) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoPara(declaracao: Para): any {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}para `;
+        this.indentacaoAtual += this.tamanhoIndentacao
+        this.devePularLinha = false;
+        if (declaracao.inicializador) {
+            if (Array.isArray(declaracao.inicializador)) {
+                this.deveIndentar = false;
+                for (let declaracaoInicializador of declaracao.inicializador) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoInicializador);
+                }
+                this.deveIndentar = true;
+            } else {
+                this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+            }
+        }
+
+        if (declaracao.condicao instanceof Binario) this.codigoFormatado += ` ate ${declaracao.condicao.direita.valor}`;
+        else this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+
+        this.codigoFormatado += ` faca${this.quebraLinha}`;
+        this.formatarDeclaracaoOuConstruto(declaracao.incrementar);
+
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.corpo.declaracoes);
+
+        this.indentacaoAtual -= this.tamanhoIndentacao
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoSe(declaracao: Se) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}se ( `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) entao${this.quebraLinha}`;
+
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of (declaracao.caminhoEntao as Bloco).declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoSenao) {
+            this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}senao${this.quebraLinha}`;
+            this.formatarDeclaracaoOuConstruto(declaracao.caminhoSenao);
+        }
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+    visitarDeclaracaoTente(declaracao: Tente) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoVar(declaracao: Var): any {
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+        }
+
+        this.codigoFormatado += `var ${declaracao.simbolo.lexema}`;
+        if (declaracao.inicializador) {
+            this.codigoFormatado += ` := `;
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+        }
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoMetodo(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAgrupamento(expressao: any): any {
+        this.codigoFormatado += '(';
+        this.formatarDeclaracaoOuConstruto(expressao.expressao);
+        this.codigoFormatado += ')';
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoBinaria(expressao: Binario) {
+        /* this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}` */
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.ADICAO:
+                this.codigoFormatado += ' + ';
+                break;
+            case tiposDeSimbolos.DIVISAO:
+                this.codigoFormatado += ' / ';
+                break;
+            case tiposDeSimbolos.DIVISAO_INTEIRA:
+                this.codigoFormatado += ' div ';
+                break;
+            case tiposDeSimbolos.IGUAL:
+                this.codigoFormatado += ' = ';
+                break;
+            case tiposDeSimbolos.MAIOR:
+                this.codigoFormatado += ' > ';
+                break;
+            case tiposDeSimbolos.MAIOR_IGUAL:
+                this.codigoFormatado += ' >= ';
+                break;
+            case tiposDeSimbolos.MENOR:
+                this.codigoFormatado += ' < ';
+                break;
+            case tiposDeSimbolos.MENOR_IGUAL:
+                this.codigoFormatado += ' <= ';
+                break;
+            case tiposDeSimbolos.SUBTRACAO:
+                this.codigoFormatado += ` - `;
+                break;
+            case tiposDeSimbolos.MULTIPLICACAO:
+                this.codigoFormatado += ` * `;
+                break;
+            case tiposDeSimbolos.MODULO:
+                this.codigoFormatado += ` mod `;
+                break;
+            case tiposDeSimbolos.EXPONENCIACAO:
+                this.codigoFormatado += ` ^ `;
+                break;
+            case tiposDeSimbolos.IGUAL_IGUAL:
+                this.codigoFormatado += ` == `;
+                break;
+            case tiposDeSimbolos.DIFERENTE:
+                this.codigoFormatado += ` <> `;
+                break;
+            default:
+                console.log(expressao.operador.tipo);
+                break;
+        }
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoBloco(declaracao: Bloco): any {
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.declaracoes);
+    }
+    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeChamada(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDefinirValor(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeleguaFuncao(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeVariavel(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDicionario(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp> {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}imprima `;
+        for (let argumento of declaracao.argumentos) {
+            const argumentoTratado = argumento as FormatacaoEscrita;
+            this.formatarDeclaracaoOuConstruto(argumentoTratado);
+            this.codigoFormatado += ', ';
+        }
+        if (declaracao.argumentos.length && this.codigoFormatado[this.codigoFormatado.length - 2] === ',') {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+    }
+    visitarExpressaoFalhar(expressao: any): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFimPara(declaracao: FimPara) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFuncaoConstruto(expressao: FuncaoConstruto) {
+        this.indentacaoAtual += this.tamanhoIndentacao;
+
+        if (expressao.parametros.length > 0) {
+            for (let parametro of expressao.parametros) {
+                if (parametro.tipoDado) {
+                    this.codigoFormatado += `${parametro.tipoDado.nome}: `
+                    switch (parametro.tipoDado.tipo.toUpperCase()) {
+                        case tiposDeSimbolos.TEXTO:
+                            this.codigoFormatado += "Caractere"
+                            break;
+                        case tiposDeSimbolos.REAL:
+                            this.codigoFormatado += "Real"
+                            break;
+                        case tiposDeSimbolos.INTEIRO:
+                            this.codigoFormatado += "Inteiro"
+                            break;
+                        default:
+                            break;
+                    }
+                    this.codigoFormatado += `, `
+                }
+            }
+            this.codigoFormatado = `${this.codigoFormatado.slice(0, -2)}): `;
+        }
+
+        for (let declaracaoCorpo of expressao.corpo) {
+            this.formatarDeclaracaoOuConstruto(declaracaoCorpo);
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+    }
+    visitarExpressaoIsto(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoLeia(expressao: Leia): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+
+    visitarExpressaoLiteral(expressao: Literal): any {
+        if (typeof expressao.valor === 'string') {
+            this.codigoFormatado += `"${expressao.valor}"`;
+            return;
+        } else if (typeof expressao.valor === "boolean") {
+            if (expressao.valor) {
+                this.codigoFormatado += "verdadeiro"
+            } else {
+                this.codigoFormatado += "falso"
+            }
+            return;
+        }
+
+        this.codigoFormatado += `${expressao.valor}`;
+    }
+
+    visitarExpressaoLogica(expressao: any) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.E:
+                this.codigoFormatado += ` e `;
+                break;
+            case tiposDeSimbolos.OU:
+                this.codigoFormatado += ` ou `;
+                break;
+            case tiposDeSimbolos.NEGACAO:
+                this.codigoFormatado += ` nao `;
+                break;
+        }
+
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoSuper(expressao: Super) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoUnaria(expressao: Unario) {
+        let operador: string;
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.SUBTRACAO:
+                operador = ` - `;
+                break;
+            case tiposDeSimbolos.ADICAO:
+                operador = ` + `;
+                break;
+            case tiposDeSimbolos.NEGACAO:
+                operador = ` nao `;
+                break;
+        }
+
+        switch (expressao.incidenciaOperador) {
+            case 'ANTES':
+                this.codigoFormatado += operador;
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                break;
+            case 'DEPOIS':
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                this.codigoFormatado += operador;
+                break;
+        }
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarExpressaoVetor(expressao: any) {
+        throw new Error('Método não implementado');
+    }
+
+    visitarDeclaracaoConstante(expressao: Constante): any {
+        this.codigoFormatado += `${expressao.simbolo.lexema}`
+    }
+
+    private formatarDeclaraTuplas(declaracao: Declaracao | Construto) {
+        const declaracoes = Object.keys(declaracao)
+        this.codigoFormatado += "("
+        for (let chaveDeclaracao of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao[chaveDeclaracao])
+            this.codigoFormatado += ", "
+        }
+        this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        this.codigoFormatado += ")"
+    }
+
+    visitarExpressaoDupla(expressao: Dupla): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+
+    visitarExpressaoTrio(expressao: Trio): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoQuarteto(expressao: Quarteto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoQuinteto(expressao: Quinteto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoSexteto(expressao: Sexteto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoSepteto(expressao: Septeto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoOcteto(expressao: Octeto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoNoneto(expressao: Noneto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+    visitarExpressaoDeceto(expressao: Deceto): any {
+        this.formatarDeclaraTuplas(expressao)
+    }
+
+    formatarDeclaracaoOuConstruto(declaracaoOuConstruto: Declaracao | Construto): void {
+        switch (declaracaoOuConstruto.constructor.name) {
+            case 'AcessoIndiceVariavel':
+                this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto as AcessoIndiceVariavel);
+                break;
+            case 'AcessoMetodoOuPropriedade':
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto as AcessoMetodoOuPropriedade);
+                break;
+            case 'Agrupamento':
+                this.visitarExpressaoAgrupamento(declaracaoOuConstruto as Agrupamento);
+                break;
+            case 'AtribuicaoPorIndice':
+                this.visitarExpressaoAtribuicaoPorIndice(declaracaoOuConstruto as AtribuicaoPorIndice);
+                break;
+            case 'Atribuir':
+                this.visitarExpressaoDeAtribuicao(declaracaoOuConstruto as Atribuir);
+                break;
+            case 'Binario':
+                this.visitarExpressaoBinaria(declaracaoOuConstruto as Binario);
+                break;
+            case 'Bloco':
+                this.visitarExpressaoBloco(declaracaoOuConstruto as Bloco);
+                break;
+            case 'Chamada':
+                this.visitarExpressaoDeChamada(declaracaoOuConstruto as Chamada);
+                break;
+            case 'Classe':
+                this.visitarDeclaracaoClasse(declaracaoOuConstruto as Classe);
+                break;
+            case 'Continua':
+                this.visitarExpressaoContinua(declaracaoOuConstruto as Continua);
+                break;
+            case 'DefinirValor':
+                this.visitarExpressaoDefinirValor(declaracaoOuConstruto as DefinirValor);
+                break;
+            case 'Dicionario':
+                this.visitarExpressaoDicionario(declaracaoOuConstruto as Dicionario);
+                break;
+            case 'Dupla':
+                this.visitarExpressaoDupla(declaracaoOuConstruto as Dupla);
+                break;
+            case 'Trio':
+                this.visitarExpressaoTrio(declaracaoOuConstruto as Trio);
+                break;
+            case 'Quarteto':
+                this.visitarExpressaoQuarteto(declaracaoOuConstruto as Quarteto);
+                break;
+            case 'Quinteto':
+                this.visitarExpressaoQuinteto(declaracaoOuConstruto as Quinteto);
+                break;
+            case 'Sexteto':
+                this.visitarExpressaoSexteto(declaracaoOuConstruto as Sexteto);
+                break;
+            case 'Septeto':
+                this.visitarExpressaoSepteto(declaracaoOuConstruto as Septeto);
+                break;
+            case 'Octeto':
+                this.visitarExpressaoOcteto(declaracaoOuConstruto as Octeto);
+                break;
+            case 'Noneto':
+                this.visitarExpressaoNoneto(declaracaoOuConstruto as Noneto);
+                break;
+            case 'Deceto':
+                this.visitarExpressaoDeceto(declaracaoOuConstruto as Deceto);
+                break;
+            case 'Escolha':
+                this.visitarDeclaracaoEscolha(declaracaoOuConstruto as Escolha);
+                break;
+            case 'Enquanto':
+                this.visitarDeclaracaoEnquanto(declaracaoOuConstruto as Enquanto);
+                break;
+            case 'Escreva':
+                this.visitarDeclaracaoEscreva(declaracaoOuConstruto as Escreva);
+                break;
+            case 'EscrevaMesmaLinha':
+                this.visitarDeclaracaoEscrevaMesmaLinha(declaracaoOuConstruto as Escreva);
+                break;
+            case 'Expressao':
+                this.visitarDeclaracaoDeExpressao(declaracaoOuConstruto as Expressao);
+                break;
+            case 'ExpressaoRegular':
+                this.visitarExpressaoExpressaoRegular(declaracaoOuConstruto as ExpressaoRegular);
+                break;
+            case 'Falhar':
+                this.visitarExpressaoFalhar(declaracaoOuConstruto as Falhar);
+                break;
+            case 'Fazer':
+                this.visitarDeclaracaoFazer(declaracaoOuConstruto as Fazer);
+                break;
+            case 'FuncaoConstruto':
+                this.visitarExpressaoFuncaoConstruto(declaracaoOuConstruto as FuncaoConstruto);
+                break;
+            case 'FuncaoDeclaracao':
+                this.visitarDeclaracaoDefinicaoFuncao(declaracaoOuConstruto as FuncaoDeclaracao);
+                break;
+            case 'Importar':
+                this.visitarDeclaracaoImportar(declaracaoOuConstruto as Importar);
+                break;
+            case 'Isto':
+                this.visitarExpressaoIsto(declaracaoOuConstruto as Isto);
+                break;
+            case 'Leia':
+                this.visitarExpressaoLeia(declaracaoOuConstruto as Leia);
+                break;
+            case 'Literal':
+                this.visitarExpressaoLiteral(declaracaoOuConstruto as Literal);
+                break;
+            case 'Logico':
+                this.visitarExpressaoLogica(declaracaoOuConstruto as Logico);
+                break;
+            case 'Para':
+                this.visitarDeclaracaoPara(declaracaoOuConstruto as Para);
+                break;
+            case 'ParaCada':
+                this.visitarDeclaracaoParaCada(declaracaoOuConstruto as ParaCada);
+                break;
+            case 'Retorna':
+                this.visitarExpressaoRetornar(declaracaoOuConstruto as Retorna);
+                break;
+            case 'Se':
+                this.visitarDeclaracaoSe(declaracaoOuConstruto as Se);
+                break;
+            case 'Super':
+                this.visitarExpressaoSuper(declaracaoOuConstruto as Super);
+                break;
+            case 'Sustar':
+                this.visitarExpressaoSustar(declaracaoOuConstruto as Sustar);
+                break;
+            case 'Tente':
+                this.visitarDeclaracaoTente(declaracaoOuConstruto as Tente);
+                break;
+            case 'TipoDe':
+                this.visitarExpressaoTipoDe(declaracaoOuConstruto as TipoDe);
+                break;
+            case 'Unario':
+                this.visitarExpressaoUnaria(declaracaoOuConstruto as Unario);
+                break;
+            case 'Const':
+                this.visitarDeclaracaoConst(declaracaoOuConstruto as Const);
+                break;
+            case 'Var':
+                this.visitarDeclaracaoVar(declaracaoOuConstruto as Var);
+                break;
+            case 'Variavel':
+                this.visitarExpressaoDeVariavel(declaracaoOuConstruto as Variavel);
+                break;
+            case 'Vetor':
+                this.visitarExpressaoVetor(declaracaoOuConstruto as Vetor);
+                break;
+            case 'Constante':
+                this.visitarDeclaracaoConstante(declaracaoOuConstruto as Constante);
+                break;
+            case 'PropriedadeClasse':
+                this.visitarExpressaoPropriedadeClasse(declaracaoOuConstruto as any);
+                break;
+            default:
+                console.log(declaracaoOuConstruto.constructor.name);
+                break;
+        }
+    }
+
+    formatar(declaracoes: Declaracao[]): string {
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = "";
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+
+        for (let declaracao of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+
+        return this.codigoFormatado;
+    }
+}
diff --git a/fontes/formatadores/index.ts b/fontes/formatadores/index.ts
index dd180e1f..33e7da91 100644
--- a/fontes/formatadores/index.ts
+++ b/fontes/formatadores/index.ts
@@ -1,3 +1,4 @@
 export * from './formatador-delegua';
 export * from './formatador-portugol-studio';
+export * from './formatador-potigol';
 export * from './formatador-visualg';
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index bf109644..aa02e492 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -1605,6 +1605,11 @@ export class InterpretadorBase implements InterpretadorInterface {
             return objeto ? 'verdadeiro' : 'falso';
         }
 
+        if (objeto instanceof RetornoQuebra) {
+            if (typeof objeto.valor === 'boolean')
+                return objeto.valor ? 'verdadeiro' : 'falso';
+        }
+
         if (objeto instanceof Date) {
             const formato = Intl.DateTimeFormat('pt', {
                 dateStyle: 'full',
@@ -1616,11 +1621,11 @@ export class InterpretadorBase implements InterpretadorInterface {
         if (Array.isArray(objeto)) {
             let retornoVetor: string = '[';
             for (let elemento of objeto) {
-                retornoVetor += `${this.paraTexto(elemento)},`;
+                retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
             }
 
             if(retornoVetor.length > 1){
-                retornoVetor = retornoVetor.slice(0, -1);
+                retornoVetor = retornoVetor.slice(0, -2);
             }
             retornoVetor += ']';
 
diff --git a/fontes/interpretador/interpretador-com-depuracao.ts b/fontes/interpretador/interpretador-com-depuracao.ts
index a5a216d6..71dc1030 100644
--- a/fontes/interpretador/interpretador-com-depuracao.ts
+++ b/fontes/interpretador/interpretador-com-depuracao.ts
@@ -1,5 +1,5 @@
 import { EspacoVariaveis } from '../espaco-variaveis';
-import { Bloco, Declaracao, Enquanto, Escreva, Leia, Para, Retorna, Var } from '../declaracoes';
+import { Bloco, Declaracao, Enquanto, Escreva, Leia, LeiaMultiplo, Para, Retorna, Var } from '../declaracoes';
 import { PontoParada } from '../depuracao';
 import { ComandoDepurador, InterpretadorComDepuracaoInterface } from '../interfaces';
 import { EscopoExecucao, TipoEscopoExecucao } from '../interfaces/escopo-execucao';
@@ -93,11 +93,13 @@ export class InterpretadorComDepuracao extends InterpretadorBase implements Inte
      */
     private async gerarIdResolucaoChamada(expressao: any): Promise<string> {
         const argumentosResolvidos = [];
-        for (let argumento of expressao.argumentos) {
-            if (argumento instanceof Leia) {
-                argumentosResolvidos.push(`leia_${argumento.id}`);
-            } else {
-                argumentosResolvidos.push(await this.avaliar(argumento));
+        if (expressao.argumentos && expressao.argumentos.length > 0) {
+            for (let argumento of expressao.argumentos) {
+                if (argumento instanceof Leia || argumento instanceof LeiaMultiplo) {
+                    argumentosResolvidos.push(`leia_${argumento.id}`);
+                } else {
+                    argumentosResolvidos.push(await this.avaliar(argumento));
+                }
             }
         }
 
diff --git a/fontes/tipos-de-simbolos/potigol.ts b/fontes/tipos-de-simbolos/potigol.ts
index 76b38fc6..9f9c56ad 100644
--- a/fontes/tipos-de-simbolos/potigol.ts
+++ b/fontes/tipos-de-simbolos/potigol.ts
@@ -33,6 +33,7 @@ export default {
     LEIA_TEXTO: 'LEIA_TEXTO',
     LEIA_TEXTOS: 'LEIA_TEXTOS',
     LOGICO: 'LOGICO',
+    LÓGICO: 'LÓGICO',
     MAIOR: 'MAIOR',
     MAIOR_IGUAL: 'MAIOR_IGUAL',
     MENOR: 'MENOR',
diff --git a/package.json b/package.json
index 75d82c68..050255b2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.33.6",
+    "version": "0.33.7",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
     "main": "index.js",
     "types": "index.d.ts",


Test patch:
diff --git a/testes/analisador-semantico.test.ts b/testes/analisador-semantico.test.ts
index ece496ed..625ce2da 100644
--- a/testes/analisador-semantico.test.ts
+++ b/testes/analisador-semantico.test.ts
@@ -841,7 +841,7 @@ describe('Analisador semântico', () => {
                     expect(retornoAnalisadorSemantico.diagnosticos.filter(item => item.severidade === DiagnosticoSeveridade.AVISO)).toHaveLength(1);
                 });
 
-                it('Sucesso - variável tipo texto não inicializada', () => {
+                it('Aviso - variável tipo texto não inicializada', () => {
                     const retornoLexador = lexador.mapear([
                         "classe Teste {}",
                         "var teste: Texto;",
@@ -853,6 +853,18 @@ describe('Analisador semântico', () => {
                     expect(retornoAnalisadorSemantico.diagnosticos).toHaveLength(1);
                     expect(retornoAnalisadorSemantico.diagnosticos.filter(item => item.severidade === DiagnosticoSeveridade.AVISO)).toHaveLength(1);
                 });
+
+                it('Erro - escreva sem parametro', () => {
+                    const retornoLexador = lexador.mapear([
+                        "escreva(); ",
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes);
+                    expect(retornoAnalisadorSemantico).toBeTruthy();
+                    expect(retornoAnalisadorSemantico.diagnosticos).toHaveLength(1);
+                    expect(retornoAnalisadorSemantico.diagnosticos.filter(item => item.severidade === DiagnosticoSeveridade.ERRO)).toHaveLength(1);
+                    expect(retornoAnalisadorSemantico.diagnosticos[0].mensagem).toBe('É preciso ter um ou mais parametros para \'escreva(...)\'');
+                });
             });
         });
     });
diff --git a/testes/biblioteca-global.test.ts b/testes/biblioteca-global.test.ts
index 9c3690d9..9da0187f 100644
--- a/testes/biblioteca-global.test.ts
+++ b/testes/biblioteca-global.test.ts
@@ -159,7 +159,7 @@ describe('Biblioteca Global', () => {
     });
 
     describe('todosEmCondicao()', () => {
-        it('Sucesso', async () => {
+        it('Sucesso - todosEmCondicao', async () => {
             const codigo = [
                 "var f = funcao(x) { retorna(x < 10) }",
                 "escreva(todosEmCondicao([1, 2, 3, 4, 5, 6], f))"
@@ -172,6 +172,25 @@ describe('Biblioteca Global', () => {
             expect(retornoInterpretador.erros).toHaveLength(0);
         });
 
+        it('Sucesso - filtrarPor', async () => {
+            const codigo = [
+                "var valoresLogicos = ['verdadeiro', 'falso', 'falso', verdadeiro, 'falso', 'verdadeiro']",
+                "var f = funcao(valor) { retorna valor == 'verdadeiro' ou valor == verdadeiro }",
+                "var valoresVerdadeiros = filtrarPor(valoresLogicos, f)",
+                "escreva(valoresVerdadeiros)"
+            ];
+            const retornoLexador = lexador.mapear(codigo, -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+            interpretador.funcaoDeRetorno = (saida: any) => {
+                expect(saida).toEqual('[\'verdadeiro\', verdadeiro, \'verdadeiro\']');
+            };
+
+            const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+            expect(retornoInterpretador.erros).toHaveLength(0);
+        });
+
         it('Falha - Funçao de mapeamento inválida', async () => {
             const codigo = [
                 "var f = 'Sou uma função'",
diff --git a/testes/interpretador/interpretador.test.ts b/testes/interpretador/interpretador.test.ts
index 54089227..fe3a2be8 100644
--- a/testes/interpretador/interpretador.test.ts
+++ b/testes/interpretador/interpretador.test.ts
@@ -1129,7 +1129,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[1,2,3]');
+                        expect(saida).toEqual('[1, 2, \'3\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1151,7 +1151,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[Olá,mundo]');
+                        expect(saida).toEqual('[\'Olá\', \'mundo\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1170,7 +1170,7 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('[maçã,banana,morango]');
+                        expect(saida).toEqual('[\'maçã\', \'banana\', \'morango\']');
                     };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1383,8 +1383,8 @@ describe('Interpretador', () => {
 
                         expect(retornoInterpretador.erros).toHaveLength(0);
                         expect(saidas).toHaveLength(2);
-                        expect(saidas[0]).toEqual('[a,b,c]');
-                        expect(saidas[1]).toEqual('[1,2,3]');
+                        expect(saidas[0]).toEqual('[\'a\', \'b\', \'c\']');
+                        expect(saidas[1]).toEqual('[1, 2, 3]');
                     });
                 });
 
@@ -1403,7 +1403,7 @@ describe('Interpretador', () => {
                         const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                         interpretador.funcaoDeRetorno = (saida: string) => {
-                            expect(saida).toEqual('[12,8,4,2]');
+                            expect(saida).toEqual('[12, 8, 4, 2]');
                         };
 
                         const retornoInterpretador = await interpretador.interpretar(
diff --git a/testes/potigol/formatador-potigol.test.ts b/testes/potigol/formatador-potigol.test.ts
new file mode 100644
index 00000000..826cfe9b
--- /dev/null
+++ b/testes/potigol/formatador-potigol.test.ts
@@ -0,0 +1,432 @@
+import * as sistemaOperacional from 'os';
+
+import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos";
+import { LexadorPotigol } from "../../fontes/lexador/dialetos";
+import { FormatadorPotigol } from "../../fontes/formatadores";
+
+describe('Formatador > Potigol', () => {
+    describe('analisar()', () => {
+        const formatadorPotigol = new FormatadorPotigol(sistemaOperacional.EOL);
+        let avaliadorSintatico = new AvaliadorSintaticoPotigol();
+        let lexador = new LexadorPotigol();
+
+        describe('Cenários de sucesso', () => {
+            describe('Entrada e saída', () => {
+                it('Sucesso - Escreva Olá Mundo', () => {
+                    const retornoLexador = lexador.mapear(['escreva "Olá mundo"'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Imprima Olá Mundo', () => {
+                    const retornoLexador = lexador.mapear(['imprima "Olá mundo"'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(1)
+                });
+            });
+
+            describe('Operações matemáticas', () => {
+                it('Sucesso - Operações encadeadas', () => {
+                    const retornoLexador = lexador.mapear(['escreva (2 * 8) - (5 / 4 ^ 7)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+                    expect(linhasResultado).toHaveLength(3)
+                });
+
+                it('Sucesso - Mod e Div', () => {
+                    const retornoLexador = lexador.mapear(['escreva (100 mod 6 div 2)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(linhasResultado).toHaveLength(2)
+                });
+            });
+
+            describe('Operações lógicas', () => {
+                it('Sucesso - Ou', () => {
+                    const retornoLexador = lexador.mapear(['verdadeiro ou falso'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(1)
+                });
+
+                it('Sucesso - Não (sem acento)', () => {
+                    const retornoLexador = lexador.mapear(['nao verdadeiro'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de igualdade', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 == 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de desigualdade', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 <> 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de menor', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 < 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de menor ou igual', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 <= 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de maior', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 > 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Comparação de maior ou igual', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 >= 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+            });
+
+            describe('Atribuição de variáveis', () => {
+                it('Sucesso - Declaração de inteiro constante, inferência', () => {
+                    const retornoLexador = lexador.mapear(['a = 10'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(linhasResultado).toHaveLength(1)
+                });
+
+                it('Sucesso - Declaração de caractere constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(["c: Real = 3.5"], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(1)
+                });
+
+                it('Sucesso - Declaração de inteiro variável, inferência', () => {
+                    const retornoLexador = lexador.mapear(['var a := 10'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sucesso - Declaração de múltiplas variáveis inteiras, inferência', () => {
+                    const retornoLexador = lexador.mapear(['var a, b, c := 10, 20, 30'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(4)
+                });
+            });
+
+            describe('Estruturas de decisão', () => {
+                it('Escolha', () => {
+                    const retornoLexador = lexador.mapear([
+                        'escolha x',
+                        '  caso 1 => escreva "Um"',
+                        '  caso 2 => escreva "Dois"',
+                        '  caso 3 => escreva "Três"',
+                        '  caso _ => escreva "Outro valor"',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(10)
+                });
+
+                it('Se', () => {
+                    const retornoLexador = lexador.mapear([
+                        'se verdadeiro então',
+                        '  escreva "verdadeiro"',
+                        'senão',
+                        '  escreva "falso"',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(8)
+                });
+            });
+
+            describe('Estruturas de repetição', () => {
+                it('Enquanto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var i := 0',
+                        'enquanto i <= 10 faça',
+                        '  escreva i',
+                        '  i := i + 1',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(5)
+                });
+
+                it('Para', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var soma := 0',
+                        'para i de 1 até 10 faça',
+                        '  soma := soma + i',
+                        'fim',
+                        'escreva "A soma é {soma}."'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+                    expect(linhasResultado).toHaveLength(5)
+                });
+            });
+
+            it('Função de uma linha, argumentos com tipo definido, sem dica de retorno', () => {
+                const retornoLexador = lexador.mapear([
+                    'soma(x: Inteiro, y: Inteiro) = x + y'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(linhasResultado).toHaveLength(1)
+            });
+            it('Função de uma linha, argumentos com tipo definido, com dica de retorno', () => {
+                const retornoLexador = lexador.mapear([
+                    'soma(x: Inteiro, y: Inteiro): Inteiro = x + y'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            describe('Declarações de tuplas', () => {
+                it('Dupla', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Trio', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Quarteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Quinteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Sexteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Septeto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Octeto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Noneto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+
+                it('Deceto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes);
+                    const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(linhasResultado).toHaveLength(2)
+                });
+            });
+        });
+    });
+});
diff --git a/testes/potigol/interpretador.test.ts b/testes/potigol/interpretador.test.ts
index 649d7779..54bceeac 100644
--- a/testes/potigol/interpretador.test.ts
+++ b/testes/potigol/interpretador.test.ts
@@ -296,7 +296,9 @@ describe('Interpretador', () => {
 
             it('Dado um leia_inteiros, escreva deve imprimir o valor lido', async () => {
                 const retornoLexador = lexador.mapear([
-                    'escreva(leia_inteiros(3))'
+                    'programa',
+                    'escreva(leia_inteiros(3))',
+                    'fim',
                 ], -1);
 
                 const respostas = [1, 2, 3];
@@ -312,7 +314,7 @@ describe('Interpretador', () => {
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                 const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-                expect(retornoInterpretador.erros).toHaveLength(0);
+                expect(retornoInterpretador.erros).toHaveLength(2);
             });
 
             it('Dado um leia_reais separador por virgula, escreva deve imprimir o valor lido', async () => {
diff --git a/testes/primitivas/primitivas-vetor.test.ts b/testes/primitivas/primitivas-vetor.test.ts
index 8435cba5..4910b0e5 100644
--- a/testes/primitivas/primitivas-vetor.test.ts
+++ b/testes/primitivas/primitivas-vetor.test.ts
@@ -1,5 +1,10 @@
 import primitivasVetor from '../../fontes/bibliotecas/primitivas-vetor';
+import { Binario, FuncaoConstruto, Literal, Logico, Variavel } from '../../fontes/construtos';
+import { Retorna } from '../../fontes/declaracoes';
+import { DeleguaFuncao } from '../../fontes/estruturas';
 import { InterpretadorBase } from '../../fontes/interpretador';
+import { Simbolo } from '../../fontes/lexador';
+import tiposDeSimbolos from '../../fontes/tipos-de-simbolos/delegua';
 
 describe('Primitivas de vetor', () => {
     let interpretador: InterpretadorBase;
@@ -32,6 +37,52 @@ describe('Primitivas de vetor', () => {
         });
     });
 
+    describe('filtrarPor()', () => {
+        it('Trivial', async () => {
+            const deleguaFuncao = new DeleguaFuncao(
+                'qualquernome', 
+                new FuncaoConstruto(
+                    -1,
+                    -1,
+                    [{
+                        abrangencia: 'padrao', 
+                        nome: new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)
+                    }],
+                    [
+                        new Retorna(
+                            new Simbolo(tiposDeSimbolos.RETORNA, 'retorna', null, -1, -1),
+                            new Logico(-1, 
+                                new Binario(
+                                    -1,
+                                    new Variavel(-1, 
+                                        new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)    
+                                    ),
+                                    new Simbolo(tiposDeSimbolos.IGUAL_IGUAL, '==', null, -1, -1),
+                                    new Literal(-1, -1, 'verdadeiro'),
+                                ),
+                                new Simbolo(tiposDeSimbolos.OU, 'ou', null, -1, -1),
+                                new Binario(
+                                    -1,
+                                    new Variavel(-1, 
+                                        new Simbolo(tiposDeSimbolos.IDENTIFICADOR, 'valor', null, -1, -1)    
+                                    ),
+                                    new Simbolo(tiposDeSimbolos.IGUAL_IGUAL, '==', null, -1, -1),
+                                    new Literal(-1, -1, true),
+                                )
+                            )
+                        )
+                    ]
+                )
+            );
+            const resultado = await primitivasVetor.filtrarPor(
+                interpretador, 
+                ['verdadeiro', 'falso', 'falso', 'verdadeiro', 'falso', 'verdadeiro'], 
+                deleguaFuncao
+            );
+            expect(resultado).toStrictEqual(['verdadeiro', 'verdadeiro', 'verdadeiro']);
+        });
+    });
+
     describe('inclui()', () => {
         it('Trivial', async () => {
             const resultado = await primitivasVetor.inclui(interpretador, [1, 2, 3], 3);