#8054

Committed 23 Jul 2025 01:31AM UTC coverage: 51.794% (+1.4%) from 50.346%

Build # #8054

Build Type

push

Committed by

Commit Message

Merge e37a5245a into cb8c6ab74

Coverage Stats

122 of 122 new or added lines in 1 file covered. (100.0%)

773 existing lines in 48 files now uncovered.

14360 of 27725 relevant lines covered (51.79%)

0.52 hits per line

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

97.67

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

package com.fincatto.documentofiscal.utils;

import java.util.Arrays;
import java.util.List;

public abstract class DFUtils {
    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.matches("^[0-9]{14}$")) {
            return false;
        }

        // verifica por falsos positivos
        if (cnpj.equalsIgnoreCase("00000000000000")) {
            return false;
        }

        String cnpjCalculado = cnpj.substring(0, 12);
        final char[] chrCNPJ = cnpj.toCharArray();

        // primeira parte
        int soma = 0;
        for (int i = 0; i < 4; i++) {
            if (((chrCNPJ[i] - 48) >= 0) && ((chrCNPJ[i] - 48) <= 9)) {
                soma += (chrCNPJ[i] - 48) * (6 - (i + 1));
            }
        }
        for (int i = 0; i < 8; i++) {
            if (((chrCNPJ[i + 4] - 48) >= 0) && ((chrCNPJ[i + 4] - 48) <= 9)) {
                soma += (chrCNPJ[i + 4] - 48) * (10 - (i + 1));
            }
        }
        int dig = 11 - (soma % 11);
        cnpjCalculado += (dig == 10) || (dig == 11) ? "0" : Integer.toString(dig);

        // segunda parte
        soma = 0;
        for (int i = 0; i < 5; i++) {
            if (((chrCNPJ[i] - 48) >= 0) && ((chrCNPJ[i] - 48) <= 9)) {
                soma += (chrCNPJ[i] - 48) * (7 - (i + 1));
            }
        }
        for (int i = 0; i < 8; i++) {
            if (((chrCNPJ[i + 5] - 48) >= 0) && ((chrCNPJ[i + 5] - 48) <= 9)) {
                soma += (chrCNPJ[i + 5] - 48) * (10 - (i + 1));
            }
        }
        dig = 11 - (soma % 11);
        cnpjCalculado += (dig == 10) || (dig == 11) ? "0" : Integer.toString(dig);
        return cnpj.equals(cnpjCalculado);
    }

    /**
     * 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.matches("^[0-9]{11}$")) {
            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);
    }
}

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

wmixvideo / nfe / #8054

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