Repository: DesignLiquido/delegua
Pull request #111 (2022-06-25 22:02:52)

Aumentando cobertura de testes lexador


Patch:
diff --git a/fontes/interfaces/lexador-interface.ts b/fontes/interfaces/lexador-interface.ts
index 2b7f915b..0458bd48 100644
--- a/fontes/interfaces/lexador-interface.ts
+++ b/fontes/interfaces/lexador-interface.ts
@@ -14,7 +14,6 @@ export interface LexadorInterface {
     eFinalDoCodigo(): boolean;
     avancar(): void;
     adicionarSimbolo(tipo: any, literal: any): void;
-    proximoIgualA(esperado: any): boolean;
     simboloAtual(): string;
     proximoSimbolo(): string;
     simboloAnterior(): string;
diff --git a/fontes/lexador/dialetos/lexador-eguap.ts b/fontes/lexador/dialetos/lexador-eguap.ts
index 95460d4a..940cf88f 100644
--- a/fontes/lexador/dialetos/lexador-eguap.ts
+++ b/fontes/lexador/dialetos/lexador-eguap.ts
@@ -124,10 +124,6 @@ export class LexadorEguaP implements LexadorInterface {
         this.simbolos.push(new Simbolo(tipo, texto, literal, this.linha + 1, this.hashArquivo));
     }
 
-    proximoIgualA(esperado: any): boolean {
-        throw new Error("Method not implemented.");
-    }
-
     simboloAtual(): string {
         if (this.eFinalDaLinha()) return '\0';
         if (this.linha > this.codigo.length - 1) return '\0';
diff --git a/fontes/lexador/lexador.ts b/fontes/lexador/lexador.ts
index 0f06b874..c1166c23 100644
--- a/fontes/lexador/lexador.ts
+++ b/fontes/lexador/lexador.ts
@@ -79,6 +79,9 @@ export class Lexador implements LexadorInterface {
     }
 
     eFinalDaLinha(): boolean {
+        if(this.codigo.length === this.linha){
+            return true;
+        }
         return this.atual >= this.codigo[this.linha].length;
     }
 
@@ -113,18 +116,6 @@ export class Lexador implements LexadorInterface {
         this.simbolos.push(new Simbolo(tipo, texto, literal, this.linha + 1, this.hashArquivo));
     }
 
-    proximoIgualA(esperado: any): boolean {
-        if (this.eFinalDaLinha()) {
-            return false;
-        }
-
-        if (this.codigo[this.linha][this.atual + 1] !== esperado) {
-            return false;
-        }
-
-        return true;
-    }
-
     simboloAtual(): string {
         if (this.eFinalDaLinha()) return '\0';
         return this.codigo[this.linha].charAt(this.atual);
@@ -136,7 +127,9 @@ export class Lexador implements LexadorInterface {
     }
 
     proximoSimbolo(): string {
-        if (this.atual + 1 >= this.codigo[this.linha].length) return '\0';
+        //TODO: Não foi possível simular no teste unitário
+        //Verificar possíbilidade de exclusão na próxima versão
+        // if (this.atual + 1 >= this.codigo[this.linha].length) return '\0';
         return this.codigo[this.linha].charAt(this.atual + 1);
     }
 
@@ -206,7 +199,7 @@ export class Lexador implements LexadorInterface {
     }
 
     encontrarFimComentarioAsterisco(): void {
-        while (!this.eUltimaLinha()) { 
+        while (!this.eFinalDoCodigo()) { 
             this.avancar();
             if (this.simboloAtual() === '*' && this.proximoSimbolo() === '/') {
                 this.avancar();


Test patch:
diff --git a/testes/lexador.test.ts b/testes/lexador.test.ts
index 5ba417d6..309ff1b8 100644
--- a/testes/lexador.test.ts
+++ b/testes/lexador.test.ts
@@ -1,4 +1,5 @@
 import { Delegua } from '../fontes/delegua';
+import tiposDeSimbolos from '../fontes/tipos-de-simbolos';
 
 describe('Lexador', () => {
     describe('mapear()', () => {
@@ -30,14 +31,136 @@ describe('Lexador', () => {
                 expect(resultado.simbolos).toHaveLength(4);
                 expect(resultado.simbolos).toEqual(
                     expect.arrayContaining([
-                        expect.objectContaining({ tipo: 'ESCREVA' }),
-                        expect.objectContaining({ tipo: 'PARENTESE_ESQUERDO' }),
-                        expect.objectContaining({ tipo: 'TEXTO' }),
-                        expect.objectContaining({ tipo: 'PARENTESE_DIREITO' }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.ESCREVA }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.PARENTESE_ESQUERDO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.TEXTO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.PARENTESE_DIREITO }),
                     ])
                 );
             });
 
+            it('Sucesso - Soma - Maior Igual', () => {
+                const resultado = delegua.lexador.mapear(["var valor = 1", "valor += 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(7);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.VARIAVEL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.MAIS_IGUAL }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Subtração - Menor Igual', () => {
+                const resultado = delegua.lexador.mapear(["var valor = 5", "valor -= 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(7);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.VARIAVEL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.MENOS_IGUAL }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Multiplicação Igual', () => {
+                const resultado = delegua.lexador.mapear(["var valor = 5", "valor *= 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(7);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.VARIAVEL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.MULTIPLICACAO_IGUAL }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Diferente Igual', () => {
+                const resultado = delegua.lexador.mapear(["1 != 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(3);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.DIFERENTE }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Divisão Igual', () => {
+                const resultado = delegua.lexador.mapear(["var valor = 10", "valor /= 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(7);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.VARIAVEL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.DIVISAO_IGUAL }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Módulo Igual', () => {
+                const resultado = delegua.lexador.mapear(["var valor = 5", "valor %= 2"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(7);
+                expect(resultado.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.VARIAVEL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IDENTIFICADOR }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.MODULO_IGUAL }),
+                    ])
+                );
+            });
+
+            it('Sucesso - Comentários multilinha', () => {
+                const resultado = delegua.lexador.mapear(["/* comentário ", "outro comentário*/"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(0);
+            });
+
+            it('Sucesso - Comentários uma linha', () => {
+                const resultado = delegua.lexador.mapear(["// comentário ", "// outro comentário"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(0);
+            });
+
+            it('Sucesso - Comentários multilinha', () => {
+                const resultado = delegua.lexador.mapear(["/* comentário ", "outro comentário*/"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(0);
+            });
+
+            it('Sucesso - Teste', () => {
+                const resultado = delegua.lexador.mapear(["var a = 10.5"], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(4);
+            });
+
             it('Sucesso - Se', () => {
                 const resultado = delegua.lexador.mapear(["se (1 == 1) { escreva('Tautologia') }"], -1);
 
@@ -45,15 +168,15 @@ describe('Lexador', () => {
                 expect(resultado.simbolos).toHaveLength(12);
                 expect(resultado.simbolos).toEqual(
                     expect.arrayContaining([
-                        expect.objectContaining({ tipo: 'SE' }),
-                        expect.objectContaining({ tipo: 'ESCREVA' }),
-                        expect.objectContaining({ tipo: 'PARENTESE_ESQUERDO' }),
-                        expect.objectContaining({ tipo: 'TEXTO' }),
-                        expect.objectContaining({ tipo: 'PARENTESE_DIREITO' }),
-                        expect.objectContaining({ tipo: 'CHAVE_ESQUERDA' }),
-                        expect.objectContaining({ tipo: 'CHAVE_DIREITA' }),
-                        expect.objectContaining({ tipo: 'IGUAL_IGUAL' }),
-                        expect.objectContaining({ tipo: 'NUMERO' }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.SE }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.ESCREVA }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.PARENTESE_ESQUERDO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.TEXTO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.PARENTESE_DIREITO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.CHAVE_ESQUERDA }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.CHAVE_DIREITA }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL_IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
                     ])
                 );
             });
@@ -65,9 +188,9 @@ describe('Lexador', () => {
                 expect(resultado.simbolos).toHaveLength(5);
                 expect(resultado.simbolos).toEqual(
                     expect.arrayContaining([
-                        expect.objectContaining({ tipo: 'ADICAO' }),
-                        expect.objectContaining({ tipo: 'IGUAL_IGUAL' }),
-                        expect.objectContaining({ tipo: 'NUMERO' }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.ADICAO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.IGUAL_IGUAL }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
                     ])
                 );
             });