@designliquido/foles
Version:
Linguagem de folhas de estilo para documentos em geral em português
726 lines (725 loc) • 130 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 importador_1 = require("../../fontes/importador");
const lexador_reverso_1 = require("../../fontes/lexador/lexador-reverso");
const avaliador_sintatico_reverso_1 = require("../../fontes/avaliador-sintatico/avaliador-sintatico-reverso");
const serializadores_1 = require("../../fontes/serializadores");
const css_1 = __importDefault(require("../../fontes/tipos-de-simbolos/css"));
const metodos_css_1 = require("../listas/metodos-css");
const declaracoes_1 = require("../../fontes/declaracoes");
const seletor_valor_reverso_1 = require("../../fontes/valores/seletor-valor-reverso");
describe('Testando MÉTODOS no processo de TRADUÇÃO REVERSA', () => {
describe('Testes Unitários', () => {
let lexador;
let importador;
let avaliador;
let tradutor;
beforeEach(() => {
lexador = new lexador_reverso_1.LexadorReverso();
importador = new importador_1.Importador(lexador);
avaliador = new avaliador_sintatico_reverso_1.AvaliadorSintaticoReverso(importador);
tradutor = new serializadores_1.SerializadorReverso();
});
it('Atribuindo Método "blur()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.MetodoBorrar[index]}: blur(${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: css_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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodoBorrar[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir blur para borrar
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBorrar[index]]);
expect(resultadoTradutor).toContain(`borrar(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "brightness()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.MetodoBrilho[index]}: brightness(${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: css_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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodoBrilho[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir brightness para brilho
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoBrilho[index]]);
expect(resultadoTradutor).toContain(`brilho(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "calc()"', () => {
for (let index = 0; index < metodos_css_1.MetodoCalcular.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodoCalcular[index]}: calc(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: css_1.default.METODO }),
]));
// O Lexador também deve encontrar números e quantificadores no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_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_css_1.MetodoCalcular[index]);
// Tradutor deve serializar de acordo e traduzir calc para calcular
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCalcular[index]]);
expect(resultadoTradutor).toContain('calcular(100px - 80px);');
}
});
it('Atribuindo Método "contrast()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.MetodoContraste[index]}: contrast(${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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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: css_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_css_1.MetodoContraste[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
// Tradutor deve serializar de acordo e traduzir contrast para contraste
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoContraste[index]]);
expect(resultadoTradutor).toContain(`contraste(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "cubic-bezier()"', () => {
for (let index = 0; index < metodos_css_1.MetodoCurvaCubica.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodoCurvaCubica[index]}: cubic-bezier(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: css_1.default.METODO }),
]));
// O Lexador também deve encontrar números no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodoCurvaCubica[index]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoCurvaCubica[index]]);
expect(resultadoTradutor).toContain('curva-cubica(0.42, 0, 1, 1);');
}
});
it('Atribuindo Método "fit-content()"', () => {
for (let index = 0; index < metodos_css_1.MetodoEncaixarConteudo.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodoEncaixarConteudo[index]}: fit-content(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: css_1.default.METODO }),
]));
// O Lexador também deve encontrar número e quantificador no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_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_css_1.MetodoEncaixarConteudo[index]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEncaixarConteudo[index]]);
expect(resultadoTradutor).toContain('encaixar-conteudo(200px)');
}
});
it('Atribuindo Método "grayscale()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.MetodoEscalaCinza[index]}: grayscale(${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: css_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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodoEscalaCinza[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoEscalaCinza[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir grayscale para escala-cinza
expect(resultadoTradutor).toContain(`escala-cinza(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "scale()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.MetodosEscalamento[index]}: scale(${valoresAceitos[valIndex]});`,
"}"
]);
// O Lexador não deve encontrar erros
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve montar um objeto de comprimento 10
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scale para escalamento
expect(resultadoTradutor).toContain(`escalamento(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "scale()" com múltiplos valores', () => {
for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodosEscalamento[index]}: scale(1.3, 0.4);`,
"}"
]);
// O Lexador não deve encontrar erros
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve montar um objeto de comprimento 12
expect(resultadoLexador.simbolos).toHaveLength(12);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scale para escalamento
expect(resultadoTradutor).toContain(`escalamento(1.3, 0.4);`);
}
});
it('Atribuindo Método "scale3d()"', () => {
for (let index = 0; index < metodos_css_1.MetodosEscalamento.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodosEscalamento[index]}: scale3d(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: css_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: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scale3d para escalamento-3d
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`escalamento-3d(0.5, 1, 1.7);`);
}
});
it('Atribuindo Método "scaleZ()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.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: css_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: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scaleZ para escalamento-eixo-z
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`escalamento-eixo-z(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "scaleX()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.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: css_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: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scaleX para escalamento-horizontal
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
expect(resultadoTradutor).toContain(`escalamento-horizontal(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "scaleY()"', () => {
for (let index = 0; index < metodos_css_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([
"div {",
`${metodos_css_1.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: css_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: css_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_css_1.MetodosEscalamento[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosEscalamento[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir scaleY para escalamento-vertical
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.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 < metodos_css_1.MetodoGradienteLinear.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.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: css_1.default.METODO }),
]));
// O Lexador também deve encontrar número e quantificador no mapeamento
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_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_css_1.MetodoGradienteLinear[index]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodoGradienteLinear[index]]);
expect(resultadoTradutor).toContain('gradiente-linear(90deg, verde, amarelo);');
}
});
it('Atribuindo Método "skew()"', () => {
for (let index = 0; index < metodos_css_1.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 {",
`${metodos_css_1.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: css_1.default.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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir skew para inclinar
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
expect(resultadoTradutor).toContain(`inclinar(${valoresAceitos[valIndex]});`);
}
}
});
it('Atribuindo Método "skew() com múltiplos valores"', () => {
for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.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: css_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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir skew para inclinar
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
expect(resultadoTradutor).toContain(`inclinar(15deg, 15deg);`);
}
});
it('Atribuindo Método "skewX()"', () => {
for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodosInclinar[index]}: skewX(${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: css_1.default.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: css_1.default.NUMERO }),
expect.objectContaining({ tipo: css_1.default.QUANTIFICADOR }),
]));
}
else {
expect(resultadoLexador.simbolos).toHaveLength(10);
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: css_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_css_1.MetodosInclinar[index]);
expect(primeiroResultadoTipado.modificadores[0].nomeFoles).toStrictEqual(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir skewX para inclinar-horizontal
expect(resultadoTradutor).toContain(metodos_css_1.TraducaoValoresMetodos[metodos_css_1.MetodosInclinar[index]]);
}
}
});
it('Atribuindo Método "skewY()"', () => {
for (let index = 0; index < metodos_css_1.MetodosInclinar.length; index += 1) {
const valoresAceitos = ['180deg', '3.142rad', '0', '1'];
for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"div {",
`${metodos_css_1.MetodosInclinar[index]}: skewY(${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: css_1.default.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: css_1.default.NUMERO }),