Implementando testes unitarios dos metodos reversos (14/43)

DesignLiquido · Dec 16, 2024 · 4e1940d · 4e1940d
1 parent ec6fc7d
commit 4e1940d
Show file tree

Hide file tree

Showing 5 changed files with 297 additions and 9 deletions.
diff --git a/fontes/valores/metodos/css/linear-gradient.ts b/fontes/valores/metodos/css/linear-gradient.ts
@@ -24,8 +24,6 @@ export class LinearGradient extends MetodoCss {
 
         const cor2 = Object.keys(cores).filter(key => cores[key] === this.cor2);
         this.cor2 = cor2.toString();
-
-        this.quantificadorAngulo === 'graus' ? this.quantificadorAngulo = 'deg' : null;
 
         return `gradiente-linear(${this.valorAngulo}${this.quantificadorAngulo}, ${this.cor1}, ${this.cor2})`
     }

diff --git a/fontes/valores/metodos/css/scaleZ.ts b/fontes/valores/metodos/css/scaleZ.ts
@@ -12,6 +12,6 @@ export class ScaleZ extends MetodoCss {
     }
 
     paraTexto() {
-        return `escalamentoZ(${this.valor1})`
+        return `escalamento-eixo-z(${this.valor1})`
     }
 }
diff --git a/fontes/valores/metodos/css/skew.ts b/fontes/valores/metodos/css/skew.ts
@@ -23,12 +23,9 @@ export class Skew extends MetodoCss {
         }
 
         if (!this.valor2 && !this.quantificador2) {
-            this.quantificador1 === 'graus' ? this.quantificador1 = 'deg' : null;
             return `inclinar(${this.valor1}${this.quantificador1})`
         }
 
-        this.quantificador1 === 'graus' ? this.quantificador1 = 'deg' : null;
-        this.quantificador2 === 'graus' ? this.quantificador2 = 'deg' : null;
         return `inclinar(${this.valor1}${this.quantificador1}, ${this.valor2}${this.quantificador2})`
     }
 }
diff --git a/testes/listas/metodos-css.ts b/testes/listas/metodos-css.ts
@@ -47,7 +47,6 @@ export const MetodoCalcular: Array<string> = [
 
 export const MetodoGradienteLinear: Array<string> = [
     'mask-image',
-    'imagem-máscara',
     'border-image-source',
     'content',
 ];

diff --git a/testes/modificadores/metodos-reversos.test.ts b/testes/modificadores/metodos-reversos.test.ts
@@ -1,6 +1,6 @@
 import { Importador } from "../../fontes/importador";
 import { AvaliadorSintaticoInterface, ImportadorInterface, LexadorInterface } from "../../fontes/interfaces";
-import { MetodoBorrar, MetodoBrilho, MetodoCalcular, MetodoContraste, MetodoCurvaCubica, MetodoEncaixarConteudo, MetodoEscalaCinza, MetodosEscalamento, TraducaoValoresMetodos } from "../listas/metodos-css";
+import { MetodoBorrar, MetodoBrilho, MetodoCalcular, MetodoContraste, MetodoCurvaCubica, MetodoEncaixarConteudo, MetodoEscalaCinza, MetodoGradienteLinear, MetodosEscalamento, MetodosInclinar, TraducaoValoresMetodos } from "../listas/metodos-css";
 import tiposDeSimbolos from "../../fontes/tipos-de-simbolos/css";
 import { LexadorReverso } from "../../fontes/lexador/lexador-reverso";
 import { AvaliadorSintaticoReverso } from "../../fontes/avaliador-sintatico/avaliador-sintatico-reverso";
@@ -387,7 +387,7 @@ describe('Testando MÉTODOS no processo de tradução reversa', () => {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "div {",
-                        `${MetodosEscalamento[index]}: scale3d(0.5, 1, 1.7);`,
+                    `${MetodosEscalamento[index]}: scale3d(0.5, 1, 1.7);`,
                     "}"
                 ]);
 
@@ -425,5 +425,299 @@ describe('Testando MÉTODOS no processo de tradução reversa', () => {
                 expect(resultadoTradutor).toContain(`escalamento-3d(0.5, 1, 1.7);`);
             }
         });
+
+        it('Atribuindo Método "scaleZ()"', () => {
+            for (let index = 0; index < MetodosEscalamento.length; index += 1) {
+
+                const valoresAceitos = ['0.1', '0', '1', '1.75'];
+
+                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "div {",
+                        `${MetodosEscalamento[index]}: scaleZ(${valoresAceitos[valIndex]});`,
+                        "}"
+                    ]);
+
+                    // O Lexador não deve encontrar erros
+                    expect(resultadoLexador.erros).toHaveLength(0);
+
+                    // O valor recebido deve ser mapeado como METODO
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                        ])
+                    );
+
+                    // O Lexador deve montar um objeto de comprimento 10
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        ])
+                    );
+
+                    // Avaliador Sintático
+                    const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                    // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                        MetodosEscalamento[index]
+                    );
+
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+
+                    // O Tradutor deve serializar de acordo e traduzir scaleZ para escalamento-eixo-z
+                    expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodosEscalamento[index]]);
+                    expect(resultadoTradutor).toContain(`escalamento-eixo-z(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+
+        it('Atribuindo Método "scaleX()"', () => {
+            for (let index = 0; index < MetodosEscalamento.length; index += 1) {
+
+                const valoresAceitos = ['0.1', '0', '1', '1.75'];
+
+                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "div {",
+                        `${MetodosEscalamento[index]}: scaleX(${valoresAceitos[valIndex]});`,
+                        "}"
+                    ]);
+
+                    // O Lexador não deve encontrar erros
+                    expect(resultadoLexador.erros).toHaveLength(0);
+
+                    // O valor recebido deve ser mapeado como METODO
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                        ])
+                    );
+
+                    // O Lexador deve montar um objeto de comprimento 10
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        ])
+                    );
+
+                    // Avaliador Sintático
+                    const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                    // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                        MetodosEscalamento[index]
+                    );
+
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+
+                    // O Tradutor deve serializar de acordo e traduzir scaleX para escalamento-horizontal
+                    expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodosEscalamento[index]]);
+                    expect(resultadoTradutor).toContain(`escalamento-horizontal(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+
+        it('Atribuindo Método "scaleY()"', () => {
+            for (let index = 0; index < MetodosEscalamento.length; index += 1) {
+
+                const valoresAceitos = ['0.1', '0', '1', '1.75'];
+
+                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "div {",
+                        `${MetodosEscalamento[index]}: scaleY(${valoresAceitos[valIndex]});`,
+                        "}"
+                    ]);
+
+                    // O Lexador não deve encontrar erros
+                    expect(resultadoLexador.erros).toHaveLength(0);
+
+                    // O valor recebido deve ser mapeado como METODO
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                        ])
+                    );
+
+                    // O Lexador deve montar um objeto de comprimento 10
+                    expect(resultadoLexador.simbolos).toHaveLength(10);
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        ])
+                    );
+
+                    // Avaliador Sintático
+                    const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                    // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                        MetodosEscalamento[index]
+                    );
+
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+
+                    // O Tradutor deve serializar de acordo e traduzir scaleY para escalamento-vertical
+                    expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodosEscalamento[index]]);
+                    expect(resultadoTradutor).toContain(`escalamento-vertical(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+
+        it('Atribuindo Método "linear-gradient()" com valor de ângulo deg', () => {
+            for (let index = 0; index < MetodoGradienteLinear.length; index += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                    `${MetodoGradienteLinear[index]}: linear-gradient(90deg, green, yellow);`,
+                    "}"
+                ]);
+
+                // O Lexador deve montar um objeto de comprimento 15 sem retornar nenhum erro
+                expect(resultadoLexador.simbolos).toHaveLength(15);
+                expect(resultadoLexador.erros).toHaveLength(0);
+
+                // O valor recebido deve ser mapeado como METODO
+                expect(resultadoLexador.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                    ])
+                );
+
+                // O Lexador também deve encontrar número e quantificador no mapeamento
+                expect(resultadoLexador.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.QUANTIFICADOR }),
+                    ])
+                );
+
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                    MetodoGradienteLinear[index]
+                );
+
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodoGradienteLinear[index]]);
+                expect(resultadoTradutor).toContain('gradiente-linear(90deg, verde, amarelo);');
+            }
+        });
+
+        it('Atribuindo Método "skew()"', () => {
+            for (let index = 0; index < MetodosInclinar.length; index += 1) {
+
+                const valoresAceitos = ['18deg', '3.142rad', '0', '1'];
+
+                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "div {",
+                            `${MetodosInclinar[index]}: skew(${valoresAceitos[valIndex]});`,
+                        "}"
+                    ]);
+
+                    // O Lexador não deve encontrar erros
+                    expect(resultadoLexador.erros).toHaveLength(0);
+
+                    // O valor recebido deve ser mapeado como METODO
+                    expect(resultadoLexador.simbolos).toEqual(
+                        expect.arrayContaining([
+                            expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                        ])
+                    );
+
+                    // O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
+                    if (valIndex <= 1) {
+                        expect(resultadoLexador.simbolos).toHaveLength(11);
+                        expect(resultadoLexador.simbolos).toEqual(
+                            expect.arrayContaining([
+                                expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                                expect.objectContaining({ tipo: tiposDeSimbolos.QUANTIFICADOR }),
+                            ])
+                        );
+                    } else {
+                        expect(resultadoLexador.simbolos).toHaveLength(10);
+                        expect(resultadoLexador.simbolos).toEqual(
+                            expect.arrayContaining([
+                                expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                            ])
+                        );
+                    }
+
+                    // Avaliador Sintático
+                    const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                    // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                    expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                        MetodosInclinar[index]
+                    );
+
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+
+                    // O Tradutor deve serializar de acordo e traduzir skew para inclinar
+                    expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodosInclinar[index]]);
+                    expect(resultadoTradutor).toContain(`inclinar(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+
+        it('Atribuindo Método "skew() com múltiplos valores"', () => {
+            for (let index = 0; index < MetodosInclinar.length; index += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "div {",
+                        `${MetodosInclinar[index]}: skew(15deg, 15deg);`,
+                    "}"
+                ]);
+
+                // O Lexador não deve encontrar erros
+                expect(resultadoLexador.erros).toHaveLength(0);
+
+                // O valor recebido deve ser mapeado como METODO
+                expect(resultadoLexador.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.METODO }),
+                    ])
+                );
+
+                // O Lexador deve montar um objeto de comprimento 14
+                expect(resultadoLexador.simbolos).toHaveLength(14);
+                expect(resultadoLexador.simbolos).toEqual(
+                    expect.arrayContaining([
+                        expect.objectContaining({ tipo: tiposDeSimbolos.NUMERO }),
+                        expect.objectContaining({ tipo: tiposDeSimbolos.QUANTIFICADOR }),
+                    ])
+                );
+
+                // Avaliador Sintático
+                const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
+
+                // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
+                expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(
+                    MetodosInclinar[index]
+                );
+
+                // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+
+                // O Tradutor deve serializar de acordo e traduzir skew para inclinar
+                expect(resultadoTradutor).toContain(TraducaoValoresMetodos[MetodosInclinar[index]]);
+                expect(resultadoTradutor).toContain(`inclinar(15deg, 15deg);`);
+            }
+        });
     });
 });