#6290

Committed 19 Apr 2016 08:37PM UTC coverage: 80.934% (+2.4%) from 78.549%

Build # #6290

Build Type

push

travis-ci

Committed by

fincatto

Commit Message

Corrigido testes.

Run Details

4470 of 5523 relevant lines covered (80.93%)

52.06 hits per line

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

94.07

/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 class StringValidador {

    private 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) {
        if (string != null) {
            StringValidador.validaTamanhoMaximo(string, 256);
        }
    }

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

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

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

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

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

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

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

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

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

    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) {
        if (string != null) {
            StringValidador.validaTamanhoExato(string, 3);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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][1-9][0-9]{6}|[1-9][0-9]{7})$").matcher(ncm);
            if (!matcher.find()) {
                throw new IllegalStateException(String.format("NCM fora do padrao (%s)", ncm));
            }
        }
    }

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

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

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

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

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

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

wmixvideo / nfe / #6290

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