#8049

Committed 10 Mar 2026 08:43PM UTC coverage: 50.346% (-1.1%) from 51.461%

Build # #8049

Build Type

push

Committed by T3W Continuous Integration

Commit Message

[maven-release-plugin] [skip ci] prepare for next development iteration

Coverage Stats

14775 of 29347 relevant lines covered (50.35%)

0.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.44

/src/main/java/com/fincatto/documentofiscal/utils/DFUtils.java

package com.fincatto.documentofiscal.utils;

import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

public abstract class DFUtils {
    private static final Pattern SOMENTE_NUMEROS = Pattern.compile("\\d+");
    private static final Pattern CNPJ_PATTERN = Pattern.compile("^[0-9A-Z]{12}[0-9]{2}$");
    private static final Pattern CPF_PATTERN = Pattern.compile("^[0-9]{11}$");

    private static final List<String> CPFS_INVALIDOS = Arrays.asList("00000000000", "11111111111", "22222222222",
            "33333333333", "44444444444", "55555555555", "66666666666", "77777777777", "88888888888", "99999999999",
            "12345678909");

    /**
     * Verifica se o CNPJ informado eh valido. <br>
     * Nao verifica o tamanho e presume que este seja de 14 digidos e somente numeros.
     *
     * @param cnpj CNPJ a ser validado.
     * @return Se o CNPJ informado eh valido ou nao.
     */
    public static boolean isCnpjValido(final String cnpj) {
        if (cnpj == null || !CNPJ_PATTERN.matcher(cnpj.toUpperCase()).matches()) {
            return false;
        }

        final String cnpjNormalizado = cnpj.toUpperCase();
        if (cnpjNormalizado.chars().distinct().count() == 1) {
            return false;
        }

        final int primeiroDigito = calcularDigitoVerificadorCnpj(cnpjNormalizado, 12);
        final int segundoDigito = calcularDigitoVerificadorCnpj(cnpjNormalizado, 13);

        return primeiroDigito == Character.getNumericValue(cnpjNormalizado.charAt(12))
                && segundoDigito == Character.getNumericValue(cnpjNormalizado.charAt(13));
    }

    private static int calcularDigitoVerificadorCnpj(final String cnpj, final int quantidadePosicoes) {
        int soma = 0;
        int peso = 2;
        for (int i = quantidadePosicoes - 1; i >= 0; i--) {
            final int valor = cnpj.charAt(i) - 48;
            soma += valor * peso;
            peso = (peso == 9) ? 2 : peso + 1;
        }
        final int resto = soma % 11;

        return (resto < 2) ? 0 : 11 - resto;
    }

    /**
     * Verifica se o CPF informado eh valido. <br>
     * Nao verifica o tamanho e presume que este seja de 11 digidos e somente numeros.
     *
     * @param cpf CPF a ser validado.
     * @return Se o CPF informado eh valido ou nao.
     */
    public static boolean isCpfValido(final String cpf) {
        if (cpf == null || !CPF_PATTERN.matcher(cpf).matches()) {
            return false;
        }

        // verifica por falsos positivos
        if (CPFS_INVALIDOS.contains(cpf)) {
            return false;
        }

        int d1 = 0, d2 = 0;
        for (int i = 1; i < 10; i++) {
            final int digitoCPF = Integer.parseInt(cpf.substring(i - 1, i));

            // multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante
            d1 += (11 - i) * digitoCPF;

            // para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior
            d2 += (12 - i) * digitoCPF;
        }

        // primeiro resto da divisao por 11
        int resto = d1 % 11;

        // se o resultado for 0 ou 1 o digito eh 0 caso contrario o digito eh 11 menos o resultado anterior
        final int digito1 = resto < 2 ? 0 : 11 - resto;

        // segundo resto da divisao por 11
        resto = (d2 + (2 * digito1)) % 11;
        // se o resultado for 0 ou 1 o digito eh 0 caso contrario o digito eh 11 menos o resultado anterior
        final int digito2 = resto < 2 ? 0 : 11 - resto;

        // digito verificador do CPF que estah sendo validado
        final String nDigVerific = cpf.substring(cpf.length() - 2);

        // concatenando o primeiro resto com o segundo
        final String nDigResult = String.valueOf(digito1) + digito2;

        // comparar o digito verificador do cpf com o primeiro resto + o segundo resto
        return nDigVerific.equals(nDigResult);
    }

    /**
     * Indica se a String informada é formada por somente caracteres numericos.
     * @param str String a ser verificada
     * @return Se a String é numerica.
     */
    public static boolean isNumerico(final String str) {
        return str != null && SOMENTE_NUMEROS.matcher(str).matches();
    }
}

1	package com.fincatto.documentofiscal.utils;
2
3	import java.util.Arrays;
4	import java.util.List;
5	import java.util.regex.Pattern;
6
7	public abstract class DFUtils {	×
8	private static final Pattern SOMENTE_NUMEROS = Pattern.compile("\\d+");	1✔
9	private static final Pattern CNPJ_PATTERN = Pattern.compile("^[0-9A-Z]{12}[0-9]{2}$");	1✔
10	private static final Pattern CPF_PATTERN = Pattern.compile("^[0-9]{11}$");	1✔
11
12	private static final List<String> CPFS_INVALIDOS = Arrays.asList("00000000000", "11111111111", "22222222222",	1✔
13	"33333333333", "44444444444", "55555555555", "66666666666", "77777777777", "88888888888", "99999999999",
14	"12345678909");
15
16	/**
17	* Verifica se o CNPJ informado eh valido. <br>
18	* Nao verifica o tamanho e presume que este seja de 14 digidos e somente numeros.
19	*
20	* @param cnpj CNPJ a ser validado.
21	* @return Se o CNPJ informado eh valido ou nao.
22	*/
23	public static boolean isCnpjValido(final String cnpj) {
24	if (cnpj == null \|\| !CNPJ_PATTERN.matcher(cnpj.toUpperCase()).matches()) {	1✔
25	return false;	1✔
26	}
27
28	final String cnpjNormalizado = cnpj.toUpperCase();	1✔
29	if (cnpjNormalizado.chars().distinct().count() == 1) {	1✔
30	return false;	1✔
31	}
32
33	final int primeiroDigito = calcularDigitoVerificadorCnpj(cnpjNormalizado, 12);	1✔
34	final int segundoDigito = calcularDigitoVerificadorCnpj(cnpjNormalizado, 13);	1✔
35
36	return primeiroDigito == Character.getNumericValue(cnpjNormalizado.charAt(12))	1✔
37	&& segundoDigito == Character.getNumericValue(cnpjNormalizado.charAt(13));	1✔
38	}
39
40	private static int calcularDigitoVerificadorCnpj(final String cnpj, final int quantidadePosicoes) {
41	int soma = 0;	1✔
42	int peso = 2;	1✔
43	for (int i = quantidadePosicoes - 1; i >= 0; i--) {	1✔
44	final int valor = cnpj.charAt(i) - 48;	1✔
45	soma += valor * peso;	1✔
46	peso = (peso == 9) ? 2 : peso + 1;	1✔
47	}
48	final int resto = soma % 11;	1✔
49
50	return (resto < 2) ? 0 : 11 - resto;	1✔
51	}
52
53	/**
54	* Verifica se o CPF informado eh valido. <br>
55	* Nao verifica o tamanho e presume que este seja de 11 digidos e somente numeros.
56	*
57	* @param cpf CPF a ser validado.
58	* @return Se o CPF informado eh valido ou nao.
59	*/
60	public static boolean isCpfValido(final String cpf) {
61	if (cpf == null \|\| !CPF_PATTERN.matcher(cpf).matches()) {	1✔
62	return false;	1✔
63	}
64
65	// verifica por falsos positivos
66	if (CPFS_INVALIDOS.contains(cpf)) {	1✔
67	return false;	1✔
68	}
69
70	int d1 = 0, d2 = 0;	1✔
71	for (int i = 1; i < 10; i++) {	1✔
72	final int digitoCPF = Integer.parseInt(cpf.substring(i - 1, i));	1✔
73
74	// multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante
75	d1 += (11 - i) * digitoCPF;	1✔
76
77	// para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior
78	d2 += (12 - i) * digitoCPF;	1✔
79	}
80
81	// primeiro resto da divisao por 11
82	int resto = d1 % 11;	1✔
83
84	// se o resultado for 0 ou 1 o digito eh 0 caso contrario o digito eh 11 menos o resultado anterior
85	final int digito1 = resto < 2 ? 0 : 11 - resto;	1✔
86
87	// segundo resto da divisao por 11
88	resto = (d2 + (2 * digito1)) % 11;	1✔
89	// se o resultado for 0 ou 1 o digito eh 0 caso contrario o digito eh 11 menos o resultado anterior
90	final int digito2 = resto < 2 ? 0 : 11 - resto;	1✔
91
92	// digito verificador do CPF que estah sendo validado
93	final String nDigVerific = cpf.substring(cpf.length() - 2);	1✔
94
95	// concatenando o primeiro resto com o segundo
96	final String nDigResult = String.valueOf(digito1) + digito2;	1✔
97
98	// comparar o digito verificador do cpf com o primeiro resto + o segundo resto
99	return nDigVerific.equals(nDigResult);	1✔
100	}
101
102	/**
103	* Indica se a String informada é formada por somente caracteres numericos.
104	* @param str String a ser verificada
105	* @return Se a String é numerica.
106	*/
107	public static boolean isNumerico(final String str) {
108	return str != null && SOMENTE_NUMEROS.matcher(str).matches();	1✔
109	}
110	}

wmixvideo / nfe / #8049

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous