@designliquido/foles
Version:
Linguagem de folhas de estilo para documentos em geral em português
742 lines (741 loc) • 148 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const avaliador_sintatico_1 = require("../../fontes/avaliador-sintatico");
const importador_1 = require("../../fontes/importador");
const lexador_1 = require("../../fontes/lexador");
const foles_1 = __importDefault(require("../../fontes/tipos-de-simbolos/foles"));
const serializadores_1 = require("../../fontes/serializadores");
const metodos_1 = require("../listas/metodos");
const declaracoes_1 = require("../../fontes/declaracoes");
const seletor_valor_1 = require("../../fontes/valores/seletor-valor");
describe('Testando Seletores que recebem MÉTODOS como valor', () => {
describe('Testes Unitários', () => {
let lexador;
let importador;
let avaliador;
let tradutor;
beforeEach(() => {
lexador = new lexador_1.Lexador();
importador = new importador_1.Importador(lexador);
avaliador = new avaliador_sintatico_1.AvaliadorSintatico(importador);
tradutor = new serializadores_1.Serializador();
});
it('Atribuindo Método "borrar()"', () => {
for (let index = 0; index < metodos_1.MetodoBorrar.length; index += 1) {
const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoBorrar[index]}: borrar(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
if (valIndex === 0 || valIndex === 1) {
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
]));
}
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
// TODO @Vitor: Alterei um caso para você.
// Os demais podem seguir a mesma lógica.
expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir borrar para blur
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBorrar[index]]);
expect(resultadoTradutor).toContain(`blur(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "brilho()"', () => {
for (let index = 0; index < metodos_1.MetodoBrilho.length; index += 1) {
const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoBrilho[index]}: brilho(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
if (valIndex === 0 || valIndex === 1) {
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir brilho para brightness
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoBrilho[index]]);
expect(resultadoTradutor).toContain(`brightness(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "calcular()"', () => {
for (let index = 0; index < metodos_1.MetodoCalcular.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoCalcular[index]}: calcular(100px - 80px);`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(14);
expect(resultadoLexador.erros).toHaveLength(0);
// O valor recebido deve ser mapeado como METODO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar números e quantificadores no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCalcular[index]]);
expect(resultadoTradutor).toContain('calc(100px - 80px);');
}
});
it('Atribuindo Método "contraste()"', () => {
for (let index = 0; index < metodos_1.MetodoContraste.length; index += 1) {
const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoContraste[index]}: contraste(${valoresAceitos[valIndex]});`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
if (valIndex === 0 || valIndex === 1) {
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
]));
}
// 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: foles_1.default.METODO }),
]));
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoContraste[index]]);
expect(resultadoTradutor).toContain(`contrast(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "curva-cúbica" (cubic-bezier)', () => {
for (let index = 0; index < metodos_1.MetodoCurvaCubica.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoCurvaCubica[index]}: curva-cúbica(0.42, 0.0, 1.0, 1.0);`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 16 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(16);
expect(resultadoLexador.erros).toHaveLength(0);
// O valor recebido deve ser mapeado como METODO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar números no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
// // // // Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoCurvaCubica[index]]);
expect(resultadoTradutor).toContain('cubic-bezier(0.42, 0, 1, 1);');
}
});
it('Atribuindo Método "encaixar-conteúdo" (fit-content)', () => {
for (let index = 0; index < metodos_1.MetodoEncaixarConteudo.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoEncaixarConteudo[index]}: encaixar-conteúdo(200px);`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 11 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.erros).toHaveLength(0);
// O valor recebido deve ser mapeado como METODO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar número e quantificador no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
// // // Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEncaixarConteudo[index]]);
expect(resultadoTradutor).toContain('fit-content(200px)');
}
});
it('Atribuindo Método "escala-cinza()"', () => {
for (let index = 0; index < metodos_1.MetodoEscalaCinza.length; index += 1) {
const valoresAceitos = ['100px', '100%', '0.1', '0', '1', '1.75'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoEscalaCinza[index]}: escala-cinza(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
if (valIndex === 0 || valIndex === 1) {
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escala-cinza para grayscale
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoEscalaCinza[index]]);
expect(resultadoTradutor).toContain(`grayscale(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "escalamento()"', () => {
for (let index = 0; index < metodos_1.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([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 10
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento para scale
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scale(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "escalamento()" com múltiplos valores', () => {
for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento(1.3, 0.4);`,
"}"
]);
// 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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 12
expect(resultadoLexador.simbolos).toHaveLength(12);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento para scale
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scale(1.3, 0.4);`);
}
});
it('Atribuindo Método "escalamento-3d()"', () => {
for (let index = 0; index < metodos_1.MetodosEscalamento.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento-3d(0.5, 1, 1.7);`,
"}"
]);
// 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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 14
expect(resultadoLexador.simbolos).toHaveLength(14);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento-3d para scale3d
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scale3d(0.5, 1, 1.7);`);
}
});
it('Atribuindo Método "escalamento-eixo-z()"', () => {
for (let index = 0; index < metodos_1.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([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento-eixo-z(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 10
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento-eixo-z para scaleZ
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scaleZ(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "escalamento-horizontal()"', () => {
for (let index = 0; index < metodos_1.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([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento-horizontal(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 10
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento-horizontal para scaleX
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scaleX(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "escalamento-vertical()"', () => {
for (let index = 0; index < metodos_1.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([
"lmht {",
`${metodos_1.MetodosEscalamento[index]}: escalamento-vertical(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 10
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento-vertical para scaleY
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`scaleY(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "gradiente-linear()" com valor de ângulo deg', () => {
for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90deg, verde, amarelo);`,
"}"
]);
// 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: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar número e quantificador no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
expect(resultadoTradutor).toContain('linear-gradient(90deg, green, yellow);');
}
});
it('Atribuindo Método "gradiente-linear()" com valor de ângulo graus', () => {
for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(90graus, verde, amarelo);`,
"}"
]);
// 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: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar número e quantificador no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
expect(resultadoTradutor).toContain('linear-gradient(90deg, green, yellow);');
}
});
it('Atribuindo Método "gradiente-linear()" com valor de posição', () => {
for (let index = 0; index < metodos_1.MetodoGradienteLinear.length; index += 1) {
const posicoes = ['superior', 'inferior', 'direita', 'esquerda'];
for (let posIndex = 0; posIndex < posicoes.length; posIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodoGradienteLinear[index]}: gradiente-linear(${posicoes[posIndex]}, azul, vermelho);`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
expect(resultadoLexador.simbolos).toHaveLength(14);
expect(resultadoLexador.erros).toHaveLength(0);
// O valor recebido deve ser mapeado como METODO
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// O Lexador também deve encontrar um qualitativo no mapeamento, referente à posição
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
]));
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
expect(resultadoAvaliadorSintatico.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoGradienteLinear[index]]);
switch (posicoes[posIndex]) {
case 'superior':
expect(resultadoTradutor).toContain('linear-gradient(0deg, blue, red);');
break;
case 'direita':
expect(resultadoTradutor).toContain('linear-gradient(90deg, blue, red);');
break;
case 'inferior':
expect(resultadoTradutor).toContain('linear-gradient(180deg, blue, red);');
break;
case 'esquerda':
expect(resultadoTradutor).toContain('linear-gradient(270deg, blue, red);');
break;
default:
break;
}
}
}
});
it('Atribuindo Método "inclinar()"', () => {
for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
const valoresAceitos = ['90graus', '18deg', '3.142rad', '0', '1'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodosInclinar[index]}: inclinar(${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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 11 caso haja quantificador e 10 caso não haja
if (valIndex <= 2) {
expect(resultadoLexador.simbolos).toHaveLength(11);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;
expect(primeiroResultadoTipado.modificadores.length).toBeGreaterThanOrEqual(1);
expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir inclinar para skew
expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodosInclinar[index]]);
if (valIndex !== 0) {
expect(resultadoTradutor).toContain(`skew(${valoresAceitos[valIndex]});`);
}
else {
expect(resultadoTradutor).toContain(`skew(90deg);`);
}
}
}
});
it('Atribuindo Método "inclinar() com múltiplos valores"', () => {
for (let index = 0; index < metodos_1.MetodosInclinar.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`${metodos_1.MetodosInclinar[index]}: inclinar(15graus, 15graus);`,
"}"
]);
// 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: foles_1.default.METODO }),
]));
// O Lexador deve montar um objeto de comprimento 14
expect(resultadoLexador.simbolos).toHaveLength(14);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.NUMERO }),
expect.objectContaining({ tipo: foles_1.default.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.length).toBeGreaterThanOrEqual(1);
const primeiroResultado = resultadoAvaliadorSintatico[0];
expect(primeiroResultado).toBeInstanceOf(declaracoes_1.BlocoDeclaracao);
const primeiroResultadoTipado = primeiroResultado;