@designliquido/foles
Version:
Linguagem de folhas de estilo para documentos em geral em português
750 lines • 183 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");
const contador_1 = require("../../fontes/valores/metodos/foles/contador");
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 "anotação()" com valor numérico - caso de sucesso', () => {
const formasAceitas = ['anotação', 'anotacao'];
const valoresAceitos = ['1', '2', '12', '20'];
for (let valIndex = 0; valIndex < formasAceitas.length; valIndex += 1) {
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: ${formasAceitas[valIndex]}(${valoresAceitos[index]});`,
"}"
]);
// 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, incluindo mapeamento de valores numéricos
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('font-variant-alternates');
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir anotação para annotation
expect(resultadoTradutor).toContain('font-variant-alternates');
expect(resultadoTradutor).toContain(`annotation(${valoresAceitos[index]});`);
}
}
});
it('Atribuindo Método "anotação()" com valor numérico - caso de falha', () => {
const valoresAceitos = ['0', '100', '300'];
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: anotação(${valoresAceitos[index]});`,
"}"
]);
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow('O valor da função anotação() deve estar entre 1 e 99');
}
});
it('Atribuindo Método "anotação()" com valor string - caso de sucesso', () => {
const formasAceitas = ['anotação', 'anotacao'];
const valoresAceitos = ['floral', 'ruby', 'circle'];
for (let valIndex = 0; valIndex < formasAceitas.length; valIndex += 1) {
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: ${formasAceitas[valIndex]}('${valoresAceitos[index]}');`,
"}"
]);
// 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);
// 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('font-variant-alternates');
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir anotação para annotation e conter o valor string
expect(resultadoTradutor).toContain('font-variant-alternates');
expect(resultadoTradutor).toContain(`annotation('${valoresAceitos[index]}');`);
}
}
});
it('Atribuindo Método "anotação()" com valor string - caso de falha', () => {
const valoresAceitos = ['--valorPersonalizado', 'herdar', 'inicial'];
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: anotação(${valoresAceitos[index]});`,
"}"
]);
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow(`Propriedade 'variação-fonte-alternativa' com valor personalizado ${valoresAceitos[index]} inválido.`);
}
});
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 "conjunto-estilos()" - caso de sucesso', () => {
const valoresAceitos = ['1', '1, 2', '6, 12, 18'];
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: conjunto-estilos(${valoresAceitos[index]});`,
"}"
]);
// 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 contendo valores numéricos
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('font-variant-alternates');
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
// O Tradutor deve serializar de acordo e traduzir escalamento-vertical para scaleY
expect(resultadoTradutor).toContain('font-variant-alternates');
expect(resultadoTradutor).toContain(`styleset(${valoresAceitos[index]});`);
}
});
it('Atribuindo Método "conjunto-estilos()" - caso de falha', () => {
const valoresAceitos = ['0', '1, 21, 12', '3, 13, 30'];
for (let index = 0; index < valoresAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`variacao-fonte-alternativa: conjunto-estilos(${valoresAceitos[index]});`,
"}"
]);
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow('Os valores da função conjunto-estilos() devem estar entre 1 e 20');
}
});
it('Atribuindo Método "contador()"', () => {
const nomeSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'contador', 'any', 1, 2, 3);
const estiloSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'romano-maiusculo', 'any', 1, 2, 3);
const instanciaContador = new contador_1.Contador(nomeSimbolo, estiloSimbolo);
const estilosAceitos = [];
Object.keys(instanciaContador.estilosAceitos).forEach((valor) => estilosAceitos.push(valor));
const estilosTraduzidos = [];
Object.values(instanciaContador.estilosAceitos).forEach((valor) => estilosTraduzidos.push(valor));
for (let index = 0; index < estilosAceitos.length; index += 1) {
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`conteúdo: contador(contador1, ${estilosAceitos[index]});`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 12 sem retornar erros
expect(resultadoLexador.simbolos).toHaveLength(12);
expect(resultadoLexador.erros).toHaveLength(0);
// O Lexador deve mapear METODO e IDENTIFICADOR no processo
expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
expect.objectContaining({ tipo: foles_1.default.IDENTIFICADOR }),
expect.objectContaining({ tipo: foles_1.default.METODO }),
]));
// Avaliador Sintático
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// O Avaliador deve montar um objeto com o devido nome 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('content');
// Tradutor
const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
expect(resultadoTradutor).toContain('content');
expect(resultadoTradutor).toContain(`counter(contador1, ${estilosTraduzidos[index]});`);
}
});
it('Caso de Falha - Método "contador()" com valor de estilo inválido', () => {
const nomeSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'contador', 'any', 1, 2, 3);
const estiloSimbolo = new lexador_1.Simbolo('IDENTIFICADOR', 'romano-maiusculo', 'any', 1, 2, 3);
const instanciaContador = new contador_1.Contador(nomeSimbolo, estiloSimbolo);
const estilosAceitos = [];
Object.keys(instanciaContador.estilosAceitos).forEach((valor) => estilosAceitos.push(valor));
for (let index = 0; index < estilosAceitos.length; index += 1) {
const estiloErroDigitacao = estilosAceitos[index].replace(/./, "x");
// Lexador
const resultadoLexador = lexador.mapear([
"lmht {",
`conteúdo: contador(contador1, ${estiloErroDigitacao});`,
"}"
]);
// O Lexador deve montar um objeto de comprimento 12 sem retornar erros
expect(resultadoLexador.simbolos).toHaveLength(12);
expect(resultadoLexador.erros).toHaveLength(0);
// O Avaliador Sintático também deve retornar o seu objeto sem retornar erros
const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
// O Serializador deve retornar o erro de estilo inválido uma vez que não consegue traduzir o valor
expect(() => {
tradutor.serializar(resultadoAvaliadorSintatico);
}).toThrow(`Valor de estilo ${estiloErroDigitacao} inválido para a função contador().`);
}
});
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(primeiroRes