@designliquido/foles/testes/modificadores/atribuicao-abreviada.test.js

Linguagem de folhas de estilo para documentos em geral em português

"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 serializadores_1 = require("../../fontes/serializadores");
const atribuicao_abreviada_1 = require("../listas/atribuicao-abreviada");
const foles_1 = __importDefault(require("../../fontes/tipos-de-simbolos/foles"));
const superclasse_1 = require("../../fontes/modificadores/superclasse");
const declaracoes_1 = require("../../fontes/declaracoes");
describe('Testando Seletores de Atribuição Abreviada, que recebem dois ou mais valores', () => {
    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('Seletores que recebem múltiplos atributos do tipo valor-quantificador', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoAbreviadaVQ.length; index += 1) {
                const valoresAceitos = [
                    '1em',
                    '10vh 10vh',
                    '10px 50px 20px',
                    '10px 25px 10px 25px',
                ];
                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
                    const seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaVQ[index], valoresAceitos[valIndex], 'px');
                    // Lexador
                    const resultadoLexador = lexador.mapear([
                        "lmht {",
                        `${atribuicao_abreviada_1.AtribuicaoAbreviadaVQ[index]}: ${valoresAceitos[valIndex]};`,
                        "}"
                    ]);
                    // O Lexador não deve encontrar erros
                    expect(resultadoLexador.erros).toHaveLength(0);
                    // O valor recebido deve conter tanto NUMERO quanto QUANTIFICADOR
                    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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                    expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                    // Tradutor
                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                    // O Tradutor deve serializar de acordo
                    expect(resultadoTradutor).toContain('html');
                    expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                    expect(resultadoTradutor).toContain(valoresAceitos[valIndex]);
                }
            }
        });
        it('Seletores que recebem múltiplas palavras reservadas como atributo', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoAbreviadaPR.length; index += 1) {
                let seletor;
                if (index <= 5) {
                    seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaPR[index], '10', 'px');
                }
                else if (index > 5 && index <= 7) {
                    seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaPR[index], 'tracejado', null);
                }
                else {
                    seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaPR[index], 'centro', null);
                }
                const valoresAceitos = Object.keys(seletor.valoresAceitos);
                let valorPR = '';
                for (let valIndex = 0; valIndex < 2; valIndex += 1) {
                    valorPR += valoresAceitos[valIndex];
                    if (valIndex < 1) {
                        valorPR += ' ';
                    }
                }
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${atribuicao_abreviada_1.AtribuicaoAbreviadaPR[index]}: ${valorPR};`,
                    "}"
                ]);
                // O Lexador não deve encontrar erros e deve montar um objeto contendo 8 símbolos
                expect(resultadoLexador.erros).toHaveLength(0);
                expect(resultadoLexador.simbolos).toHaveLength(8);
                // 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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                // O Tradutor deve serializar de acordo
                expect(resultadoTradutor).toContain('html');
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
            }
        });
        it('Seletores que recebem palavras reservadas específicas como atributo', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas[index]['modificador'], atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas[index]['valor']);
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas[index]['modificador']}: ${atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas[index]['valor']};`,
                    "}"
                ]);
                // O Lexador não deve encontrar erros ao fazer o mapeamento
                expect(resultadoLexador.erros).toHaveLength(0);
                // 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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                // O Tradutor deve serializar de acordo
                expect(resultadoTradutor).toContain('html');
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                expect(resultadoTradutor).toContain(atribuicao_abreviada_1.AtribuicaoAbreviadaPREspecificas[index]['traducao']);
            }
        });
        it('Seletores que recebem tanto palavras reservadas quanto valor-quantificador como atributo', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR[index]['modificador'], atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR[index]['valor'], index === atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR.length - 1 ? 'deg' : 'px');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR[index]['modificador']}: ${atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR[index]['valor']};`,
                    "}"
                ]);
                // O Lexador não deve encontrar erros
                expect(resultadoLexador.erros).toHaveLength(0);
                // O valor recebido deve conter tanto NUMERO quanto QUANTIFICADOR
                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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                // O Tradutor deve serializar de acordo
                expect(resultadoTradutor).toContain('html');
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                expect(resultadoTradutor).toContain(atribuicao_abreviada_1.AtribuicaoAbreviadaVQePR[index]['traducao']);
            }
        });
        it('Seletores que recebem atribuição de valores separados por BARRA', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra[index]['modificador'], atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra[index]['valor'], 'px');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra[index]['modificador']}: ${atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra[index]['valor']};`,
                    "}"
                ]);
                // O Lexador não deve encontrar erros
                expect(resultadoLexador.erros).toHaveLength(0);
                // O Lexador deve mapear os devidos símbolos de acordo com o seletor recebido
                if (index <= 1) {
                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                        expect.objectContaining({ tipo: foles_1.default.QUALITATIVO }),
                    ]));
                }
                else if (index > 1 && index <= 3) {
                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                        expect.objectContaining({ tipo: foles_1.default.NUMERO }),
                    ]));
                }
                else {
                    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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                // O Tradutor deve serializar de acordo
                expect(resultadoTradutor).toContain('html');
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                expect(resultadoTradutor).toContain(atribuicao_abreviada_1.AtribuicaoSeparadaPorBarra[index]['valor']);
            }
        });
        it('Seletores que recebem atribuição de valores separados por VÍRGULA', () => {
            for (let index = 0; index < atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula.length; index += 1) {
                const seletor = new superclasse_1.SeletorModificador(atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula[index]['modificador'], atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula[index]['valor'], 's');
                // Lexador
                const resultadoLexador = lexador.mapear([
                    "lmht {",
                    `${atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula[index]['modificador']}: ${atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula[index]['valor']};`,
                    "}"
                ]);
                // O Lexador não deve encontrar erros
                expect(resultadoLexador.erros).toHaveLength(0);
                // O Lexador deve mapear os devidos símbolos de acordo com o seletor recebido
                if (index <= 1) {
                    expect(resultadoLexador.simbolos).toEqual(expect.arrayContaining([
                        expect.objectContaining({ tipo: foles_1.default.IDENTIFICADOR }),
                    ]));
                }
                else {
                    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].nomeFoles).toStrictEqual(seletor['nomeFoles']);
                expect(primeiroResultadoTipado.modificadores[0].propriedadeCss).toStrictEqual(seletor['propriedadeCss']);
                // Tradutor
                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
                // O Tradutor deve serializar de acordo
                expect(resultadoTradutor).toContain('html');
                expect(resultadoTradutor).toContain(seletor['propriedadeCss']);
                expect(resultadoTradutor).toContain(atribuicao_abreviada_1.AtribuicaoSeparadaPorVirgula[index]['traducao']);
            }
        });
    });
});
//# sourceMappingURL=atribuicao-abreviada.test.js.map