#7126

Committed 09 Aug 2016 11:45AM UTC coverage: 78.549% (-0.6%) from 79.109%

Build # #7126

Build Type

push

travis-ci

Committed by

jefperito

Commit Message

Corrigido erro de javadoc

Erro corrigido: Exit code: 1 -
/home/travis/build/wmixvideo/nfe/src/main/java/com/fincatto/nfe310/class
es/NFAutorizador31.java:93: error: bad use of '>'

Run Details

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

321 existing lines in 19 files now uncovered.

4764 of 6065 relevant lines covered (78.55%)

50.43 hits per line

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

94.54

/src/main/java/com/fincatto/nfe310/validadores/StringValidador.java

package com.fincatto.nfe310.validadores;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;

public abstract class StringValidador {

    public static void mmaaaa(final String mmaaaa) {
        try {
            new SimpleDateFormat("mm/yyyy").parse(mmaaaa);
        } catch (final ParseException e) {
            throw new IllegalStateException(String.format("Formato invalido (mm/aaaa) (%s)", mmaaaa));
        }
    }

    public static void aamm(final String aamm) {
        try {
            new SimpleDateFormat("yymm").parse(aamm);
        } catch (final ParseException e) {
            throw new IllegalStateException(String.format("Formato invalido (aamm) (%s)", aamm));
        }
    }

    public static void codigoDeBarras(final String codigoDeBarras) {
        final Matcher matcher = Pattern.compile("^([0-9]{0}|[0-9]{8}|[0-9]{12,14})$").matcher(codigoDeBarras);
        if (!matcher.find()) {
            throw new IllegalStateException(String.format("Codigo de barras com formato invalido (%s)", codigoDeBarras));
        }
    }

    public static void telefone(final String telefone) {
        if (telefone != null) {
            final Matcher matcher = Pattern.compile("^[0-9]{6,14}$").matcher(telefone);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Telefone de tamanho invalido (%s)", telefone));
            }
        }
    }

    public static void tamanho256(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 256, info);
        }
    }

    public static void tamanho9(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 9, info);
        }
    }

    public static void tamanho60(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 60, info);
        }
    }

    public static void tamanho2ate60(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 2, 60, info);
        }
    }

    public static void tamanho22(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 22, info);
        }
    }

    public static void tamanho21(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 21, info);
        }
    }

    public static void tamanho20(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 20, info);
        }
    }

    public static void tamanho2000(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 2000, info);
        }
    }

    public static void tamanho5000(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 5000, info);
        }
    }

    public static void tamanho40(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 40, info);
        }
    }

    public static void placaDeVeiculo(final String placaVeiculo) {
        if (placaVeiculo != null) {
            final Matcher matcher = Pattern.compile("^([A-Z]{2,3}[0-9]{4}|[A-Z]{3,4}[0-9]{3})$").matcher(placaVeiculo);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Placa de veiculo nao esta no padrao (%s)", placaVeiculo));
            }
        }
    }

    public static void cnpj(final String cnpj) {
        if (cnpj != null) {
            final Matcher matcher = Pattern.compile("^[0-9]{14}$").matcher(cnpj);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Formato CNPJ Invalido (%s)", cnpj));
            }
        }
    }

    public static void cpf(final String cpf) {
        if (cpf != null) {
            final Matcher matcher = Pattern.compile("^[0-9]{11}$").matcher(cpf);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Formato CPF Invalido (%s)", cpf));
            }
        }
    }

    public static void inscricaoEstadual(final String inscricaoEstadual) {
        if (inscricaoEstadual != null) {
            final Matcher matcher = Pattern.compile("^(ISENTO|[0-9]{2,14}|)$").matcher(inscricaoEstadual);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Inscricao estadual invalido (%s)", inscricaoEstadual));
            }
        }
    }

    public static void inscricaoEstadualSemIsencao(final String inscricaoEstadual) {
        if (inscricaoEstadual != null) {
            final Matcher matcher = Pattern.compile("^([0-9]{2,14}|)$").matcher(inscricaoEstadual);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("Inscricao estadual invalido (%s)", inscricaoEstadual));
            }
        }
    }

    public static void exatamente3(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 3, info);
        }
    }

    public static void exatamente5(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 5, info);
        }
    }

    public static void exatamente9(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 9, info);
        }
    }

    public static void exatamente17(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 17, info);
        }
    }

    public static void exatamente4(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 4, info);
        }
    }

    public static void exatamente6(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 6, info);
        }
    }

    public static void exatamente21(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 21, info);
        }
    }

    public static void exatamente1(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 1, info);
        }
    }

    public static void tamanho15(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 15, info);
        }
    }

    public static void tamanho12(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 12, info);
        }
    }

    public static void tamanho120(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 120, info);
        }
    }

    public static void tamanho6(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 6, info);
        }
    }

    public static void tamanho500(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 500, info);
        }
    }

    public static void tamanho3(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 3, info);
        }
    }

    public static void exatamente7(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 7, info);
        }
    }

    public static void exatamente8(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 8, info);
        }
    }

    public static void exatamente2(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 2, info);
        }
    }

    public static void tamanho8a9(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 8, 9, info);
        }
    }

    public static void tamanho15a256(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 15, 256, info);
        }
    }

    public static void tamanho15a255(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 15, 255, info);
        }
    }

    public static void tamanho5a20(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 5, 20, info);
        }
    }

    public static void tamanho5a60(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 5, 60, info);
        }
    }

    public static void tamanho2a4(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 2, 4, info);
        }
    }

    public static void tamanho8a9N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.intervalo(string, 8, 9, info);
        }
    }

    public static void tamanho15a1000(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 15, 1000, info);
        }
    }

    public static void tamanho100a600(final String string, final String info) {
        if (string != null) {
            StringValidador.intervalo(string, 100, 600, info);
        }
    }

    public static void tamanho30(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 30, info);
        }
    }

    public static void exatamente44(final String string, final String info) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 44, info);
        }
    }

    public static void exatamente7N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.exatamente7(string, info);
        }
    }

    public static void exatamente44N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.exatamente44(string, info);
        }
    }

    public static void exatamente4N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.exatamente4(string, info);
        }
    }

    public static void exatamente6N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.exatamente6(string, info);
        }
    }

    public static void tamanho15N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.validaTamanhoMaximo(string, 15, info);
        }
    }

    public static void tamanho9N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.validaTamanhoMaximo(string, 9, info);
        }
    }

    public static void tamanho2ou3N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.intervalo(string, 2, 3, info);
        }
    }

    public static void tamanho3N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.validaTamanhoMaximo(string, 3, info);
        }
    }

    public static void exatamente20N(final String string, final String info) {
        if (string != null) {
            StringValidador.apenasNumerico(string, info);
            StringValidador.validaTamanhoExato(string, 20, info);
        }
    }

    public static void fci(final String numeroControleFCI) {
        if (numeroControleFCI != null) {
            final Matcher matcher = Pattern.compile("^([A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12})$").matcher(numeroControleFCI);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("FCI fora do padrao (%s)", numeroControleFCI));
            }
        }
    }

    public static void ncm(final String ncm) {
        if (ncm != null) {
            final Matcher matcher = Pattern.compile("^([0-9]{2}|[0-9]{8})$").matcher(ncm);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("NCM fora do padrao (%s)", ncm));
            }
        }
    }

    private static void apenasNumerico(final String string, final String info) {
        if (!StringUtils.isNumeric(string)) {
            throw new IllegalStateException(String.format("A string %s precisa ser numerica (%s)", info, string));
        }
    }

    private static void validaTamanhoMaximo(final String string, final int tamanho, final String info) {
        if (string.length() < 1 || string.length() > tamanho) {
            throw new IllegalStateException(String.format("%s \"%s\" deve possuir entre 1-%s caracteres", info, string, tamanho));
        }
    }

    private static void validaTamanhoExato(final String string, final int tamanho, final String info) {
        if (string.length() != tamanho) {
            throw new IllegalStateException(String.format("%s \"%s\" deve possuir %s caracteres", info, string, tamanho));
        }
    }

    private static void intervalo(final String string, final int inicio, final int fim, final String info) {
        if (string.length() < inicio || string.length() > fim) {
            throw new IllegalStateException(String.format("%s \"%s\" deve possuir entre %s-%s caracteres", info, string, inicio, fim));
        }
    }

    public static void nve(final String nve) {
        final Matcher matcher = Pattern.compile("^[A-Z]{2}[0-9]{4}$").matcher(nve);
        if (!matcher.find()) {
            throw new IllegalStateException(String.format("NVE fora do padrao (%s)", nve));
        }
    }

    public static void itemListaServico(final String itemListaServicos) {
        final Matcher matcher = Pattern.compile("^\\d{2}\\.\\d{2}$").matcher(itemListaServicos);
        if (!matcher.find()) {
            throw new IllegalStateException(String.format("Item Lista de servico fora do padrao (%s)", itemListaServicos));
        }
    }

    public static void exatamente54(final String string, final String info) {
        StringValidador.validaTamanhoExato(string, 54, info);
    }

    public static void exatamente15N(final String string, final String info) {
        StringValidador.validaTamanhoExato(string, 15, info);
        StringValidador.apenasNumerico(string, info);
    }

    public static void modeloDocumentoFiscal(final String modeloDocumentoFiscal) {
        if (!modeloDocumentoFiscal.equals("55") && !modeloDocumentoFiscal.equals("65")) {
            throw new IllegalStateException(String.format("Modelo Fiscal Invalido (%s)", modeloDocumentoFiscal));
        }
    }

    public static void identificador(final String identificador) {
        final Matcher matcher = Pattern.compile("^ID\\d{41}$").matcher(identificador);
        if (!matcher.find()) {
            throw new IllegalStateException(String.format("Identificador fora do padrao (%s)", identificador));
        }
    }
}

1	package com.fincatto.nfe310.validadores;
2
3	import java.text.ParseException;
4	import java.text.SimpleDateFormat;
5	import java.util.regex.Matcher;
6	import java.util.regex.Pattern;
7
8	import org.apache.commons.lang3.StringUtils;
9
UNCOV 10	public abstract class StringValidador {	×
11
12	public static void mmaaaa(final String mmaaaa) {
13	try {
14	new SimpleDateFormat("mm/yyyy").parse(mmaaaa);	40✔
15	} catch (final ParseException e) {	2✔
16	throw new IllegalStateException(String.format("Formato invalido (mm/aaaa) (%s)", mmaaaa));	2✔
17	}	38✔
18	}	38✔
19
20	public static void aamm(final String aamm) {
21	try {
22	new SimpleDateFormat("yymm").parse(aamm);	24✔
UNCOV 23	} catch (final ParseException e) {	×
UNCOV 24	throw new IllegalStateException(String.format("Formato invalido (aamm) (%s)", aamm));	×
25	}	24✔
26	}	24✔
27
28	public static void codigoDeBarras(final String codigoDeBarras) {
29	final Matcher matcher = Pattern.compile("^([0-9]{0}\|[0-9]{8}\|[0-9]{12,14})$").matcher(codigoDeBarras);	156✔
30	if (!matcher.find()) {	156✔
31	throw new IllegalStateException(String.format("Codigo de barras com formato invalido (%s)", codigoDeBarras));	14✔
32	}
33	}	142✔
34
35	public static void telefone(final String telefone) {
36	if (telefone != null) {	143✔
37	final Matcher matcher = Pattern.compile("^[0-9]{6,14}$").matcher(telefone);	143✔
38	if (!matcher.find()) {	143✔
39	throw new IllegalStateException(String.format("Telefone de tamanho invalido (%s)", telefone));	4✔
40	}
41	}
42	}	139✔
43
44	public static void tamanho256(final String string, final String info) {
45	if (string != null) {	16✔
46	StringValidador.validaTamanhoMaximo(string, 256, info);	16✔
47	}
48	}	14✔
49
50	public static void tamanho9(final String string, final String info) {
51	if (string != null) {	71✔
52	StringValidador.validaTamanhoMaximo(string, 9, info);	71✔
53	}
54	}	69✔
55
56	public static void tamanho60(final String string, final String info) {
57	if (string != null) {	2,453✔
58	StringValidador.validaTamanhoMaximo(string, 60, info);	2,453✔
59	}
60	}	2,379✔
61
62	public static void tamanho2ate60(final String string, final String info) {
63	if (string != null) {	170✔
64	StringValidador.intervalo(string, 2, 60, info);	170✔
65	}
66	}	168✔
67
68	public static void tamanho22(final String string, final String info) {
69	if (string != null) {	42✔
70	StringValidador.validaTamanhoMaximo(string, 22, info);	42✔
71	}
72	}	38✔
73
74	public static void tamanho21(final String string, final String info) {
75	if (string != null) {	20✔
76	StringValidador.validaTamanhoMaximo(string, 21, info);	20✔
77	}
78	}	18✔
79
80	public static void tamanho20(final String string, final String info) {
81	if (string != null) {	320✔
82	StringValidador.validaTamanhoMaximo(string, 20, info);	320✔
83	}
84	}	309✔
85
86	public static void tamanho2000(final String string, final String info) {
87	if (string != null) {	39✔
88	StringValidador.validaTamanhoMaximo(string, 2000, info);	39✔
89	}
90	}	38✔
91
92	public static void tamanho5000(final String string, final String info) {
93	if (string != null) {	39✔
94	StringValidador.validaTamanhoMaximo(string, 5000, info);	39✔
95	}
96	}	38✔
97
98	public static void tamanho40(final String string, final String info) {
99	if (string != null) {	30✔
100	StringValidador.validaTamanhoMaximo(string, 40, info);	30✔
101	}
102	}	28✔
103
104	public static void placaDeVeiculo(final String placaVeiculo) {
105	if (placaVeiculo != null) {	59✔
106	final Matcher matcher = Pattern.compile("^([A-Z]{2,3}[0-9]{4}\|[A-Z]{3,4}[0-9]{3})$").matcher(placaVeiculo);	59✔
107	if (!matcher.find()) {	59✔
108	throw new IllegalStateException(String.format("Placa de veiculo nao esta no padrao (%s)", placaVeiculo));	6✔
109	}
110	}
111	}	53✔
112
113	public static void cnpj(final String cnpj) {
114	if (cnpj != null) {	509✔
115	final Matcher matcher = Pattern.compile("^[0-9]{14}$").matcher(cnpj);	508✔
116	if (!matcher.find()) {	508✔
117	throw new IllegalStateException(String.format("Formato CNPJ Invalido (%s)", cnpj));	25✔
118	}
119	}
120	}	484✔
121
122	public static void cpf(final String cpf) {
123	if (cpf != null) {	73✔
124	final Matcher matcher = Pattern.compile("^[0-9]{11}$").matcher(cpf);	71✔
125	if (!matcher.find()) {	71✔
126	throw new IllegalStateException(String.format("Formato CPF Invalido (%s)", cpf));	16✔
127	}
128	}
129	}	57✔
130
131	public static void inscricaoEstadual(final String inscricaoEstadual) {
132	if (inscricaoEstadual != null) {	158✔
133	final Matcher matcher = Pattern.compile("^(ISENTO\|[0-9]{2,14}\|)$").matcher(inscricaoEstadual);	158✔
134	if (!matcher.find()) {	158✔
135	throw new IllegalStateException(String.format("Inscricao estadual invalido (%s)", inscricaoEstadual));	5✔
136	}
137	}
138	}	153✔
139
140	public static void inscricaoEstadualSemIsencao(final String inscricaoEstadual) {
141	if (inscricaoEstadual != null) {	43✔
142	final Matcher matcher = Pattern.compile("^([0-9]{2,14}\|)$").matcher(inscricaoEstadual);	43✔
143	if (!matcher.find()) {	43✔
UNCOV 144	throw new IllegalStateException(String.format("Inscricao estadual invalido (%s)", inscricaoEstadual));	×
145	}
146	}
147	}	43✔
148
149	public static void exatamente3(final String string, final String info) {
150	if (string != null) {	66✔
151	StringValidador.validaTamanhoExato(string, 3, info);	66✔
152	}
153	}	63✔
154
155	public static void exatamente5(final String string, final String info) {
156	if (string != null) {	57✔
157	StringValidador.validaTamanhoExato(string, 5, info);	57✔
158	}
159	}	56✔
160
161	public static void exatamente9(final String string, final String info) {
162	if (string != null) {	50✔
163	StringValidador.validaTamanhoExato(string, 9, info);	50✔
164	}
165	}	46✔
166
167	public static void exatamente17(final String string, final String info) {
168	if (string != null) {	30✔
169	StringValidador.validaTamanhoExato(string, 17, info);	30✔
170	}
171	}	28✔
172
173	public static void exatamente4(final String string, final String info) {
174	if (string != null) {	213✔
175	StringValidador.validaTamanhoExato(string, 4, info);	213✔
176	}
177	}	205✔
178
179	public static void exatamente6(final String string, final String info) {
180	if (string != null) {	68✔
181	StringValidador.validaTamanhoExato(string, 6, info);	68✔
182	}
183	}	65✔
184
185	public static void exatamente21(final String string, final String info) {
186	if (string != null) {	30✔
187	StringValidador.validaTamanhoExato(string, 21, info);	30✔
188	}
189	}	28✔
190
191	public static void exatamente1(final String string, final String info) {
192	if (string != null) {	31✔
193	StringValidador.validaTamanhoExato(string, 1, info);	31✔
194	}
195	}	28✔
196
197	public static void tamanho15(final String string, final String info) {
198	if (string != null) {	176✔
199	StringValidador.validaTamanhoMaximo(string, 15, info);	176✔
200	}
201	}	170✔
202
203	public static void tamanho12(final String string, final String info) {
204	if (string != null) {	73✔
205	StringValidador.validaTamanhoMaximo(string, 12, info);	73✔
206	}
207	}	71✔
208
209	public static void tamanho120(final String string, final String info) {
210	if (string != null) {	61✔
211	StringValidador.validaTamanhoMaximo(string, 120, info);	61✔
212	}
213	}	59✔
214
215	public static void tamanho6(final String string, final String info) {
216	if (string != null) {	120✔
217	StringValidador.validaTamanhoMaximo(string, 6, info);	120✔
218	}
219	}	116✔
220
221	public static void tamanho500(final String string, final String info) {
222	if (string != null) {	38✔
223	StringValidador.validaTamanhoMaximo(string, 500, info);	38✔
224	}
225	}	36✔
226
227	public static void tamanho3(final String string, final String info) {
228	if (string != null) {	58✔
229	StringValidador.validaTamanhoMaximo(string, 3, info);	58✔
230	}
231	}	57✔
232
233	public static void exatamente7(final String string, final String info) {
234	if (string != null) {	389✔
235	StringValidador.validaTamanhoExato(string, 7, info);	389✔
236	}
237	}	382✔
238
239	public static void exatamente8(final String string, final String info) {
240	if (string != null) {	156✔
241	StringValidador.validaTamanhoExato(string, 8, info);	155✔
242	}
243	}	154✔
244
245	public static void exatamente2(final String string, final String info) {
246	if (string != null) {	37✔
247	StringValidador.validaTamanhoExato(string, 2, info);	37✔
248	}
249	}	31✔
250
251	public static void tamanho8a9(final String string, final String info) {
UNCOV 252	if (string != null) {	×
UNCOV 253	StringValidador.intervalo(string, 8, 9, info);	×
254	}
255	}	×
256
257	public static void tamanho15a256(final String string, final String info) {
258	if (string != null) {	68✔
259	StringValidador.intervalo(string, 15, 256, info);	68✔
260	}
261	}	66✔
262
263	public static void tamanho15a255(final String string, final String info) {
264	if (string != null) {	15✔
265	StringValidador.intervalo(string, 15, 255, info);	15✔
266	}
267	}	13✔
268
269	public static void tamanho5a20(final String string, final String info) {
UNCOV 270	if (string != null) {	×
UNCOV 271	StringValidador.intervalo(string, 5, 20, info);	×
272	}
273	}	×
274
275	public static void tamanho5a60(final String string, final String info) {
276	if (string != null) {	24✔
277	StringValidador.intervalo(string, 5, 60, info);	24✔
278	}
279	}	24✔
280
281	public static void tamanho2a4(final String string, final String info) {
282	if (string != null) {	95✔
283	StringValidador.intervalo(string, 2, 4, info);	95✔
284	}
285	}	95✔
286
287	public static void tamanho8a9N(final String string, final String info) {
288	if (string != null) {	43✔
289	StringValidador.apenasNumerico(string, info);	43✔
290	StringValidador.intervalo(string, 8, 9, info);	41✔
291	}
292	}	41✔
293
294	public static void tamanho15a1000(final String string, final String info) {
UNCOV 295	if (string != null) {	×
UNCOV 296	StringValidador.intervalo(string, 15, 1000, info);	×
297	}
298	}	×
299
300	public static void tamanho100a600(final String string, final String info) {
301	if (string != null) {	1✔
302	StringValidador.intervalo(string, 100, 600, info);	1✔
303	}
304	}	1✔
305
306	public static void tamanho30(final String string, final String info) {
307	if (string != null) {	25✔
308	StringValidador.validaTamanhoMaximo(string, 30, info);	25✔
309	}
310	}	25✔
311
312	public static void exatamente44(final String string, final String info) {
313	if (string != null) {	651✔
314	StringValidador.validaTamanhoExato(string, 44, info);	651✔
315	}
316	}	645✔
317
318	public static void exatamente7N(final String string, final String info) {
319	if (string != null) {	219✔
320	StringValidador.apenasNumerico(string, info);	219✔
321	StringValidador.exatamente7(string, info);	217✔
322	}
323	}	214✔
324
325	public static void exatamente44N(final String string, final String info) {
326	if (string != null) {	652✔
327	StringValidador.apenasNumerico(string, info);	652✔
328	StringValidador.exatamente44(string, info);	651✔
329	}
330	}	645✔
331
332	public static void exatamente4N(final String string, final String info) {
333	if (string != null) {	94✔
334	StringValidador.apenasNumerico(string, info);	94✔
335	StringValidador.exatamente4(string, info);	94✔
336	}
337	}	93✔
338
339	public static void exatamente6N(final String string, final String info) {
340	if (string != null) {	60✔
341	StringValidador.apenasNumerico(string, info);	60✔
342	StringValidador.exatamente6(string, info);	59✔
343	}
344	}	58✔
345
346	public static void tamanho15N(final String string, final String info) {
347	if (string != null) {	18✔
348	StringValidador.apenasNumerico(string, info);	18✔
349	StringValidador.validaTamanhoMaximo(string, 15, info);	15✔
350	}
351	}	12✔
352
353	public static void tamanho9N(final String string, final String info) {
354	if (string != null) {	30✔
355	StringValidador.apenasNumerico(string, info);	30✔
356	StringValidador.validaTamanhoMaximo(string, 9, info);	28✔
357	}
358	}	26✔
359
360	public static void tamanho2ou3N(final String string, final String info) {
361	if (string != null) {	65✔
362	StringValidador.apenasNumerico(string, info);	65✔
363	StringValidador.intervalo(string, 2, 3, info);	64✔
364	}
365	}	61✔
366
367	public static void tamanho3N(final String string, final String info) {
368	if (string != null) {	15✔
369	StringValidador.apenasNumerico(string, info);	15✔
370	StringValidador.validaTamanhoMaximo(string, 3, info);	14✔
371	}
372	}	13✔
373
374	public static void exatamente20N(final String string, final String info) {
375	if (string != null) {	7✔
376	StringValidador.apenasNumerico(string, info);	7✔
377	StringValidador.validaTamanhoExato(string, 20, info);	7✔
378	}
379	}	6✔
380
381	public static void fci(final String numeroControleFCI) {
382	if (numeroControleFCI != null) {	17✔
383	final Matcher matcher = Pattern.compile("^([A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12})$").matcher(numeroControleFCI);	17✔
384	if (!matcher.find()) {	17✔
385	throw new IllegalStateException(String.format("FCI fora do padrao (%s)", numeroControleFCI));	1✔
386	}
387	}
388	}	16✔
389
390	public static void ncm(final String ncm) {
391	if (ncm != null) {	70✔
392	final Matcher matcher = Pattern.compile("^([0-9]{2}\|[0-9]{8})$").matcher(ncm);	70✔
393	if (!matcher.find()) {	70✔
394	throw new IllegalStateException(String.format("NCM fora do padrao (%s)", ncm));	8✔
395	}
396	}
397	}	62✔
398
399	private static void apenasNumerico(final String string, final String info) {
400	if (!StringUtils.isNumeric(string)) {	1,214✔
401	throw new IllegalStateException(String.format("A string %s precisa ser numerica (%s)", info, string));	14✔
402	}
403	}	1,200✔
404
405	private static void validaTamanhoMaximo(final String string, final int tamanho, final String info) {
406	if (string.length() < 1 \|\| string.length() > tamanho) {	3,638✔
407	throw new IllegalStateException(String.format("%s \"%s\" deve possuir entre 1-%s caracteres", info, string, tamanho));	122✔
408	}
409	}	3,516✔
410
411	private static void validaTamanhoExato(final String string, final int tamanho, final String info) {
412	if (string.length() != tamanho) {	1,820✔
413	throw new IllegalStateException(String.format("%s \"%s\" deve possuir %s caracteres", info, string, tamanho));	50✔
414	}
415	}	1,770✔
416
417	private static void intervalo(final String string, final int inicio, final int fim, final String info) {
418	if (string.length() < inicio \|\| string.length() > fim) {	478✔
419	throw new IllegalStateException(String.format("%s \"%s\" deve possuir entre %s-%s caracteres", info, string, inicio, fim));	9✔
420	}
421	}	469✔
422
423	public static void nve(final String nve) {
424	final Matcher matcher = Pattern.compile("^[A-Z]{2}[0-9]{4}$").matcher(nve);	57✔
425	if (!matcher.find()) {	57✔
426	throw new IllegalStateException(String.format("NVE fora do padrao (%s)", nve));	1✔
427	}
428	}	56✔
429
430	public static void itemListaServico(final String itemListaServicos) {
431	final Matcher matcher = Pattern.compile("^\\d{2}\\.\\d{2}$").matcher(itemListaServicos);	27✔
432	if (!matcher.find()) {	27✔
433	throw new IllegalStateException(String.format("Item Lista de servico fora do padrao (%s)", itemListaServicos));	2✔
434	}
435	}	25✔
436
437	public static void exatamente54(final String string, final String info) {
438	StringValidador.validaTamanhoExato(string, 54, info);	23✔
439	}	23✔
440
441	public static void exatamente15N(final String string, final String info) {
442	StringValidador.validaTamanhoExato(string, 15, info);	13✔
443	StringValidador.apenasNumerico(string, info);	11✔
444	}	10✔
445
446	public static void modeloDocumentoFiscal(final String modeloDocumentoFiscal) {
447	if (!modeloDocumentoFiscal.equals("55") && !modeloDocumentoFiscal.equals("65")) {	16✔
448	throw new IllegalStateException(String.format("Modelo Fiscal Invalido (%s)", modeloDocumentoFiscal));	1✔
449	}
450	}	15✔
451
452	public static void identificador(final String identificador) {
453	final Matcher matcher = Pattern.compile("^ID\\d{41}$").matcher(identificador);	14✔
454	if (!matcher.find()) {	14✔
455	throw new IllegalStateException(String.format("Identificador fora do padrao (%s)", identificador));	1✔
456	}
457	}	13✔
458	}

wmixvideo / nfe / #7126

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