@designliquido/foles 0.6.1 → 0.6.3

package/testes/modificadores/metodos.test.js

@@ -21,6 +21,190 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
             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
+                    expect(resultadoAvaliadorSintatico[0].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[0].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[0].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[0].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[0].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
@@ -50,6 +234,167 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 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[0].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 "gradiente-linear()" com valor de ângulo', () => {
+            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[0].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[0].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 "inverter()"', () => {
+            for (let index = 0; index < metodos_1.MetodoInverter.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.MetodoInverter[index]}: inverter(${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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir inverter para invert
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoInverter[index]]);
+                    expect(resultadoTradutor).toContain(`invert(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
         it('Atribuindo Método "limitar" (clamp)', () => {
             for (let index = 0; index < metodos_1.MetodoLimitar.length; index += 1) {
                 // Lexador
@@ -80,6 +425,35 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoTradutor).toContain('clamp(10vw, 20em, 100vw);');
             }
         });
+        it('Atribuindo Método "linear()"', () => {
+            for (let index = 0; index < metodos_1.MetodoLinear.length; index += 1) {
+                // Lexador
+                const resultadoLexador = lexador.mapear([
+                    "lmht {",
+                    `${metodos_1.MetodoLinear[index]}: linear(0, 0.25, 1);`,
+                    "}"
+                ]);
+                // 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 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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
+                // // // // Tradutor
+                const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
+                expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
+            }
+        });
         it('Atribuindo Método "minmax()"', () => {
             for (let index = 0; index < metodos_1.MetodoMinMax.length; index += 1) {
                 // Lexador
@@ -110,6 +484,48 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoTradutor).toContain('minmax(100px, max-content);');
             }
         });
+        it('Atribuindo Método "opacar()"', () => {
+            for (let index = 0; index < metodos_1.MetodoOpacar.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.MetodoOpacar[index]}: opacar(${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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir opacar para opacity
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoOpacar[index]]);
+                    expect(resultadoTradutor).toContain(`opacity(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
         it('Atribuindo Método "passos" (steps)', () => {
             for (let index = 0; index < metodos_1.MetodoPassos.length; index += 1) {
                 // Lexador
@@ -140,62 +556,262 @@ describe('Testando Seletores que recebem MÉTODOS como valor', () => {
                 expect(resultadoTradutor).toContain('steps(2, jump-start);');
             }
         });
-        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[0].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 "projetar-sombra()" com valores de comprimento somente', () => {
+            for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
+                const comprimentos = ['15px 15px', '15px 15px 15px', '0.5rem 0.5rem', '0.5rem 0.5rem 1rem'];
+                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "lmht {",
+                        `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
+                        "}"
+                    ]);
+                    // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
+                    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 sempre encontrar valores e quantificadores na operação
+                    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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir projetar-sombra para drop-shadow  
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                    expect(resultadoTradutor).toContain(`drop-shadow(${comprimentos[posIndex]});`);
+                }
             }
         });
-        it('Atribuindo Método "linear()"', () => {
-            for (let index = 0; index < metodos_1.MetodoLinear.length; index += 1) {
+        it('Atribuindo Método "projetar-sombra()" com valores de cor e de comprimento', () => {
+            for (let index = 0; index < metodos_1.MetodoProjetarSombra.length; index += 1) {
+                const comprimentos = ['15px 15px vermelho', '15px 15px 15px vermelho', 'vermelho 0.5rem 0.5rem', 'vermelho 0.5rem 0.5rem 1rem'];
+                for (let posIndex = 0; posIndex < comprimentos.length; posIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "lmht {",
+                        `${metodos_1.MetodoProjetarSombra[index]}: projetar-sombra(${comprimentos[posIndex]});`,
+                        "}"
+                    ]);
+                    // O Lexador deve montar um objeto de acordo, sem retornar nenhum erro
+                    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 sempre encontrar valores e quantificadores na operação
+                    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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir vermelho para red
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoProjetarSombra[index]]);
+                    expect(resultadoTradutor).toContain('red');
+                }
+            }
+        });
+        it('Atribuindo Método "raio()" com valores de posição e número/quantificador', () => {
+            for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
+                const valoresAceitos = ['lado-mais-próximo', 'lado-mais-proximo', 'canto-mais-próximo', 'canto-mais-proximo', 'lado-mais-distante', 'canto-mais-distante', 'lados', 'conter'];
+                const traducaoValoresAceitos = ['closest-side', 'closest-side', 'closest-corner', 'closest-corner', 'farthest-side', 'farthest-corner', 'sides', 'contain'];
+                for (let valIndex = 0; valIndex < valoresAceitos.length; valIndex += 1) {
+                    // Lexador
+                    const resultadoLexador = lexador.mapear([
+                        "lmht {",
+                        `${metodos_1.MetodoRaio[index]}: raio(${valoresAceitos[valIndex]} 200deg);`,
+                        "}"
+                    ]);
+                    // 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 }),
+                        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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir raio para ray
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                    expect(resultadoTradutor).toContain(`ray(${traducaoValoresAceitos[valIndex]} 200deg);`);
+                }
+            }
+        });
+        it('Atribuindo Método "raio()" com somente número/quantificador', () => {
+            for (let index = 0; index < metodos_1.MetodoRaio.length; index += 1) {
                 // Lexador
                 const resultadoLexador = lexador.mapear([
                     "lmht {",
-                    `${metodos_1.MetodoLinear[index]}: linear(0, 0.25, 1);`,
+                    `${metodos_1.MetodoRaio[index]}: raio(200deg);`,
                     "}"
                 ]);
-                // O Lexador deve montar um objeto de comprimento 14 sem retornar nenhum erro
-                expect(resultadoLexador.simbolos).toHaveLength(14);
+                // 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 também deve encontrar números no mapeamento
+                // O Lexador deve montar um objeto de comprimento 11
+                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 }),
                 ]));
                 // Avaliador Sintático
                 const resultadoAvaliadorSintatico = avaliador.analisar(resultadoLexador.simbolos);
                 // O Avaliador deve montar um objeto com os devidos nomes FolEs e CSS
-                expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
-                // // // // Tradutor
+                expect(resultadoAvaliadorSintatico[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                // Tradutor
                 const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
-                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoLinear[index]]);
-                expect(resultadoTradutor).toContain('linear(0, 0.25, 1);');
+                // O Tradutor deve serializar de acordo e traduzir raio para ray
+                expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRaio[index]]);
+                expect(resultadoTradutor).toContain(`ray(200deg);`);
+            }
+        });
+        it('Atribuindo Método "rotacionar-matiz()"', () => {
+            for (let index = 0; index < metodos_1.MetodoRotacionarMatiz.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.MetodoRotacionarMatiz[index]}: rotacionar-matiz(${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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir rotacionar-matiz para hue-rotate
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoRotacionarMatiz[index]]);
+                    expect(resultadoTradutor).toContain(`hue-rotate(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+        it('Atribuindo Método "saturar()"', () => {
+            for (let index = 0; index < metodos_1.MetodoSaturar.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.MetodoSaturar[index]}: saturar(${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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir saturar para saturate
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSaturar[index]]);
+                    expect(resultadoTradutor).toContain(`saturate(${valoresAceitos[valIndex]});`);
+                }
+            }
+        });
+        it('Atribuindo Método "sepia()"', () => {
+            for (let index = 0; index < metodos_1.MetodoSepia.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.MetodoSepia[index]}: sepia(${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[0].modificadores[0].propriedadeCss).toStrictEqual(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
+                    // Tradutor
+                    const resultadoTradutor = tradutor.serializar(resultadoAvaliadorSintatico);
+                    // O Tradutor deve serializar de acordo e traduzir sépia para sepia
+                    expect(resultadoTradutor).toContain(metodos_1.TraducaoValoresMetodos[metodos_1.MetodoSepia[index]]);
+                    expect(resultadoTradutor).toContain(`sepia(${valoresAceitos[valIndex]});`);
+                }
             }
         });
     });