VERIFICA
Gerada por tools/gerar_documentacao.py. Definição: tests/test_biblioteca.c:15.
Macro do harness unitário que conta uma condição e registra falha sem abortar o grupo.
Tipo: macro com argumentos · Módulo/categoria: Macros dos testes.
Assinatura e expansão
#define VERIFICA(condicao) do { \
++verificacoes; \
if (!(condicao)) { \
++falhas; \
(void) fprintf(stderr, "FALHA %s:%d: %s\n", __FILE__, __LINE__, \
#condicao); \
} \
} while (0)
Parâmetros formais: condicao.
Corpo da macro:
do { \
++verificacoes; \
if (!(condicao)) { \
++falhas; \
(void) fprintf(stderr, "FALHA %s:%d: %s\n", __FILE__, __LINE__, \
#condicao); \
} \
} while (0)
Como funciona
Incrementa verificacoes, avalia a condição uma vez e, em falha, incrementa falhas e imprime a expressão stringificada com arquivo/linha. O main retorna 1 se houver falhas.
- Contagem estática de macro expansões não é igual ao número de verificações executadas em loops/plataformas.
Como este símbolo aparece nos testes
239 ocorrência(s) em 1 arquivo(s) de teste. Os links apontam para linhas exatas; os trechos mostram o contexto local. Uma menção não prova que todos os ramos foi executado.
tests/test_biblioteca.c
Contexto: testa_caracteres, testa_console, testa_entrada_numerica, testa_matematica, testa_texto, testa_utilidades. Linhas: 48, 49, 50, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 76, 77, 78, 79, 80, 81, 82, 86, 94, 95, 96, 97, 101, 102, 103, 104 …. Tipo de evidência: código; via VERIFICA.
Linhas 46–52 · abrir contexto
FILE *limite = cria_arquivo_temporario("x\n\n");
VERIFICA(entrada != NULL);
VERIFICA(saida != NULL);
VERIFICA(limite != NULL);
if (entrada == NULL || saida == NULL || limite == NULL) {
if (entrada != NULL) (void) fclose(entrada);
Linhas 56–88 · abrir contexto
}
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(strcmp(buffer, "abc") == 0);
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(strcmp(buffer, "1234567") == 0);
VERIFICA(bg_leia_linha(entrada, buffer, 5) == false);
VERIFICA(buffer[0] == '\0');
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(buffer[0] == '\0'); /* linha vazia é sucesso */
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(strcmp(buffer, "crlf") == 0);
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(strcmp(buffer, "final") == 0); /* última linha sem LF */
VERIFICA(!bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(buffer[0] == '\0');
VERIFICA(!bg_leia_linha(NULL, buffer, sizeof buffer));
VERIFICA(buffer[0] == '\0');
(void) fclose(entrada);
VERIFICA(!bg_leia_linha(limite, uma_posicao, 0));
VERIFICA(uma_posicao[0] == 'x'); /* capacidade zero não autoriza escrita */
VERIFICA(!bg_leia_linha(limite, uma_posicao, sizeof uma_posicao));
VERIFICA(uma_posicao[0] == '\0'); /* nenhum byte cabe além do NUL */
VERIFICA(bg_leia_linha(limite, uma_posicao, sizeof uma_posicao));
VERIFICA(uma_posicao[0] == '\0'); /* linha vazia cabe até em capacidade 1 */
VERIFICA(!bg_leia_linha(limite, NULL, 1));
(void) fclose(limite);
entrada = tmpfile();
VERIFICA(entrada != NULL);
if (entrada != NULL) {
(void) fputc('a', entrada);
Linhas 92–110 · abrir contexto
(void) fputs("ok\n", entrada);
rewind(entrada);
VERIFICA(!bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(buffer[0] == '\0');
VERIFICA(bg_leia_linha(entrada, buffer, sizeof buffer));
VERIFICA(strcmp(buffer, "ok") == 0);
(void) fclose(entrada);
}
VERIFICA(bg_escreva_texto(saida, "literal %s%n"));
VERIFICA(bg_escreva_linha(saida, " linha"));
VERIFICA(!bg_escreva_texto(saida, NULL));
VERIFICA(!bg_escreva_linha(saida, NULL));
VERIFICA(!bg_escreva_texto(NULL, "nao escreve"));
rewind(saida);
VERIFICA(fgets(lido, sizeof lido, saida) != NULL);
VERIFICA(strcmp(lido, "literal %s%n linha\n") == 0);
(void) fclose(saida);
}
Linhas 116–136 · abrir contexto
FILE *entrada = cria_arquivo_temporario("-12\n3.125\n4x\n1e9999\n");
VERIFICA(entrada != NULL);
if (entrada == NULL) {
return;
}
VERIFICA(bg_leia_inteiro_de(entrada, &inteiro));
VERIFICA(inteiro == -12);
VERIFICA(bg_leia_real_de(entrada, &real));
VERIFICA(real == 3.125);
inteiro = 71;
VERIFICA(!bg_leia_inteiro_de(entrada, &inteiro));
VERIFICA(inteiro == 71); /* saída não muda em falha */
real = 8.25;
VERIFICA(!bg_leia_real_de(entrada, &real));
VERIFICA(real == 8.25);
VERIFICA(!bg_leia_inteiro_de(entrada, &inteiro)); /* EOF */
VERIFICA(!bg_leia_inteiro_de(NULL, &inteiro));
VERIFICA(!bg_leia_inteiro_de(entrada, NULL));
(void) fclose(entrada);
}
Linhas 151–254 · abrir contexto
size_t i;
VERIFICA(bg_tamanho_texto(NULL) == 0);
VERIFICA(bg_tamanho_texto("abc") == 3);
VERIFICA(bg_copia_texto(buffer, sizeof buffer, "abc"));
VERIFICA(strcmp(buffer, "abc") == 0);
VERIFICA(bg_copia_texto(buffer, sizeof buffer, NULL));
VERIFICA(buffer[0] == '\0');
VERIFICA(bg_copia_texto(pequeno, sizeof pequeno, "abc")); /* capacidade exata */
VERIFICA(strcmp(pequeno, "abc") == 0);
VERIFICA(!bg_copia_texto(pequeno, sizeof pequeno, "quatro"));
VERIFICA(pequeno[0] == '\0');
VERIFICA(!bg_copia_texto(NULL, 1, "x"));
VERIFICA(!bg_copia_texto(buffer, 0, "x"));
VERIFICA(bg_junta_texto(buffer, sizeof buffer, "ab", "cd"));
VERIFICA(strcmp(buffer, "abcd") == 0);
VERIFICA(bg_junta_texto(justo, sizeof justo, "ab", "cd"));
VERIFICA(strcmp(justo, "abcd") == 0); /* 4 bytes + NUL cabem exatamente */
VERIFICA(bg_junta_texto(buffer, sizeof buffer, NULL, "x"));
VERIFICA(strcmp(buffer, "x") == 0);
VERIFICA(bg_copia_texto(buffer, sizeof buffer, "abcd"));
VERIFICA(bg_junta_texto(buffer, sizeof buffer, buffer, buffer + 1));
VERIFICA(strcmp(buffer, "abcdbcd") == 0); /* origens sobrepostas */
VERIFICA(!bg_junta_texto(pequeno, sizeof pequeno, "ab", "cd"));
VERIFICA(pequeno[0] == '\0');
VERIFICA(!bg_junta_texto(NULL, 0, "a", "b"));
VERIFICA(bg_copia_texto(buffer, sizeof buffer, "ab"));
VERIFICA(bg_acrescenta_texto(buffer, sizeof buffer, "cd"));
VERIFICA(strcmp(buffer, "abcd") == 0);
VERIFICA(bg_copia_texto(buffer, sizeof buffer, "ab"));
VERIFICA(bg_acrescenta_texto(buffer, 5, "cd"));
VERIFICA(strcmp(buffer, "abcd") == 0); /* capacidade exata */
VERIFICA(bg_acrescenta_texto(buffer, sizeof buffer, buffer));
VERIFICA(strcmp(buffer, "abcdabcd") == 0);
VERIFICA(!bg_acrescenta_texto(buffer, 8, "x"));
VERIFICA(buffer[0] == '\0');
VERIFICA(!bg_acrescenta_texto(NULL, 0, "x"));
VERIFICA(bg_trecho_texto(buffer, sizeof buffer, "abcdef", 2, 3));
VERIFICA(strcmp(buffer, "cde") == 0);
VERIFICA(bg_trecho_texto(buffer, sizeof buffer, "abcdef", 4, SIZE_MAX));
VERIFICA(strcmp(buffer, "ef") == 0);
VERIFICA(bg_trecho_texto(buffer, sizeof buffer, "abc", SIZE_MAX, 1));
VERIFICA(buffer[0] == '\0');
VERIFICA(bg_trecho_texto(buffer, sizeof buffer, "abc", 1, 0));
VERIFICA(buffer[0] == '\0');
VERIFICA(bg_trecho_texto(justo, sizeof justo, "abc", 0, 3));
VERIFICA(strcmp(justo, "abc") == 0); /* capacidade exata */
VERIFICA(!bg_trecho_texto(pequeno, sizeof pequeno, "abcdef", 0, 4));
VERIFICA(pequeno[0] == '\0');
VERIFICA(bg_copia_texto(buffer, sizeof buffer, "abcdef"));
VERIFICA(bg_trecho_texto(buffer, sizeof buffer, buffer, 2, 3));
VERIFICA(strcmp(buffer, "cde") == 0);
VERIFICA(bg_compara_texto("a", "b") == -1);
VERIFICA(bg_compara_texto("b", "a") == 1);
VERIFICA(bg_compara_texto("a", "a") == 0);
VERIFICA(bg_compara_texto(NULL, "") == 0);
VERIFICA(bg_texto_vazio(NULL));
VERIFICA(bg_texto_vazio(""));
VERIFICA(!bg_texto_vazio(" "));
VERIFICA(bg_formata_texto(formato, sizeof formato, "%s-%d", "id", 42));
VERIFICA(strcmp(formato, "id-42") == 0);
VERIFICA(bg_formata_texto(pequeno, sizeof pequeno, "%d", 123));
VERIFICA(strcmp(pequeno, "123") == 0); /* capacidade exata */
VERIFICA(!bg_formata_texto(pequeno, sizeof pequeno, "%s", "longo"));
VERIFICA(pequeno[0] == '\0');
(void) strcpy(pequeno, "x");
VERIFICA(!bg_formata_texto(pequeno, sizeof pequeno, NULL));
VERIFICA(pequeno[0] == '\0');
VERIFICA(!bg_formata_texto(NULL, sizeof formato, "%d", 1));
VERIFICA(!bg_formata_texto(formato, 0, "%d", 1));
errno = EDOM;
(void) snprintf(formato, sizeof formato, " \t%d \n", INT_MIN);
VERIFICA(bg_texto_para_inteiro(formato, &inteiro));
VERIFICA(errno == EDOM);
VERIFICA(inteiro == INT_MIN);
(void) snprintf(formato, sizeof formato, "%d", INT_MAX);
VERIFICA(bg_texto_para_inteiro(formato, &inteiro));
VERIFICA(inteiro == INT_MAX);
inteiro_antes = inteiro;
VERIFICA(!bg_texto_para_inteiro("12abc", &inteiro));
VERIFICA(inteiro == inteiro_antes);
VERIFICA(!bg_texto_para_inteiro("", &inteiro));
VERIFICA(!bg_texto_para_inteiro(NULL, &inteiro));
VERIFICA(!bg_texto_para_inteiro("1", NULL));
VERIFICA(bg_texto_para_natural(" +123 \t", &natural));
VERIFICA(natural == 123U);
(void) snprintf(formato, sizeof formato, "%u", UINT_MAX);
VERIFICA(bg_texto_para_natural(formato, &natural));
VERIFICA(natural == UINT_MAX);
natural_antes = natural;
VERIFICA(!bg_texto_para_natural("-1", &natural));
VERIFICA(natural == natural_antes);
VERIFICA(!bg_texto_para_natural("7x", &natural));
VERIFICA(!bg_texto_para_natural(NULL, &natural));
VERIFICA(!bg_texto_para_natural("1", NULL));
for (i = 0; i + 1 < sizeof numero_grande; ++i) {
Linhas 256–307 · abrir contexto
}
numero_grande[sizeof numero_grande - 1] = '\0';
VERIFICA(!bg_texto_para_inteiro(numero_grande, &inteiro));
VERIFICA(!bg_texto_para_natural(numero_grande, &natural));
errno = EDOM;
VERIFICA(bg_texto_para_real(" 3.5 \t", &real));
VERIFICA(errno == EDOM);
VERIFICA(real == 3.5);
real_antes = real;
VERIFICA(!bg_texto_para_real("2,5", &real));
VERIFICA(real == real_antes);
VERIFICA(!bg_texto_para_real("1e9999", &real));
VERIFICA(!bg_texto_para_real("1e-9999", &real));
VERIFICA(!bg_texto_para_real("3.5x", &real));
VERIFICA(!bg_texto_para_real(NULL, &real));
VERIFICA(!bg_texto_para_real("1", NULL));
VERIFICA(bg_numero_para_inteiro(12.9, &inteiro));
VERIFICA(inteiro == 12);
VERIFICA(bg_numero_para_inteiro(-12.9, &inteiro));
VERIFICA(inteiro == -12);
inteiro_antes = inteiro;
VERIFICA(!bg_numero_para_inteiro(NAN, &inteiro));
VERIFICA(inteiro == inteiro_antes);
VERIFICA(!bg_numero_para_inteiro(HUGE_VAL, &inteiro));
VERIFICA(!bg_numero_para_inteiro(-HUGE_VAL, &inteiro));
VERIFICA(!bg_numero_para_inteiro(1.0, NULL));
}
static void testa_caracteres(void)
{
VERIFICA(bg_e_digito('0'));
VERIFICA(bg_e_digito('9'));
VERIFICA(!bg_e_digito('/'));
VERIFICA(!bg_e_digito('a'));
VERIFICA(bg_e_letra('A'));
VERIFICA(bg_e_letra('z'));
VERIFICA(!bg_e_letra('0'));
VERIFICA(!bg_e_letra((char) 127));
VERIFICA(bg_caractere_maiusculo('q') == 'Q');
VERIFICA(bg_caractere_maiusculo('Q') == 'Q');
VERIFICA(bg_caractere_maiusculo('7') == '7');
VERIFICA(bg_caractere_minusculo('Q') == 'q');
VERIFICA(bg_caractere_minusculo('q') == 'q');
VERIFICA(bg_caractere_minusculo('7') == '7');
VERIFICA(E_DIGITO('5'));
VERIFICA(E_LETRA('b'));
VERIFICA(CARACTERE_MAIUSCULO('b') == 'B');
VERIFICA(CARACTERE_MINUSCULO('B') == 'b');
}
2 outros blocos de contexto: use os links de linha e o JSON de inventário.
Compiladores, padrão C e sistema operacional
Nenhum ramo condicional externo foi detectado para este símbolo. A implementação é compartilhada no fonte; isso não certifica compiladores ou sistemas não executados.
- Fora das extensões opcionais, a linguagem exige C11; diferenças de tipo, libc e CRT continuam sendo as do alvo.
A matriz histórica distingue executado, compilado, avaliado e não testado. Consulte a matriz, os compiladores e os logs atuais dos workflows antes de chamar um alvo de suportado.
Perguntas frequentes
Perguntas reunidas a partir da definição, do contrato editorial e dos testes de VERIFICA. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.
Em uma frase, o que VERIFICA faz?
Macro do harness unitário que conta uma condição e registra falha sem abortar o grupo.
Para que exatamente VERIFICA expande?
O pré-processador substitui VERIFICA pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.
Parâmetros formais: condicao.
do { \
++verificacoes; \
if (!(condicao)) { \
++falhas; \
(void) fprintf(stderr, "FALHA %s:%d: %s\n", __FILE__, __LINE__, \
#condicao); \
} \
} while (0)
Como VERIFICA aparece em código real deste repositório?
Uso extraído de tests/test_biblioteca.c:46, com as linhas vizinhas preservadas:
FILE *limite = cria_arquivo_temporario("x\n\n");
VERIFICA(entrada != NULL);
VERIFICA(saida != NULL);
VERIFICA(limite != NULL);
Onde VERIFICA é exercitado nos testes?
Há 239 ocorrência(s) em 1 arquivo(s): tests/test_biblioteca.c. Os links da seção de evidência apontam para a linha exata; uma menção não prova que todos os ramos foram executados.
VERIFICA depende de compilador, padrão C ou sistema operacional?
VERIFICA é código interno em C: compila com C11 nos alvos exercitados, mas não faz parte da API pública nem da matriz de portabilidade da linguagem.
Quais armadilhas preciso evitar ao usar VERIFICA?
O contrato editorial registra: “Contagem estática de macro expansões não é igual ao número de verificações executadas em loops/plataformas.”