EXIGE
Gerada por tools/gerar_documentacao.py. Definição: tests/portabilidade/fronteira.c:23.
Conta a verificação antes de avaliar, para o número final dizer quantas
Tipo: macro com argumentos · Módulo/categoria: Macros dos testes.
Assinatura e expansão
#define EXIGE(cond) \
do { \
verificacoes++; \
AFIRME((cond), "verificacao de fronteira falhou"); \
} while (0)
Parâmetros formais: cond.
Corpo da macro:
do { \
verificacoes++; \
AFIRME((cond), "verificacao de fronteira falhou"); \
} while (0)
Como funciona
Conta a verificação antes de avaliar, para o número final dizer quantas asserções este arquivo tem (serve de alarme se alguém apagar uma).
Nomes internos referenciados: AFIRME.
Como este símbolo aparece nos testes
176 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/portabilidade/fronteira.c
Contexto: fronteira.c. Linhas: 31, 32, 33, 40, 41, 42, 43, 44, 45, 46, 47, 48, 56, 57, 58, 59, 60, 61, 62, 63, 65, 66, 74, 75, 76, 77, 78, 79, 80, 82, 83, 85, 86, 90, 91 …. Tipo de evidência: código; via EXIGE.
Linhas 29–35 · abrir contexto
INICIO
/* ------------------------------------------------ texto: tamanho */
EXIGE(bg_tamanho_texto(NULL) == 0);
EXIGE(bg_tamanho_texto("") == 0);
EXIGE(bg_tamanho_texto("abc") == 3);
/* ------------------------------------------- texto: cópia exata */
Linhas 38–50 · abrir contexto
dst[0] = 'x'; dst[1] = 'x'; dst[2] = 'x'; dst[3] = 'x';
EXIGE(bg_copia_texto(dst, 4, "abc") == true); /* 3 + NUL = 4: cabe */
EXIGE(dst[0] == 'a' E dst[1] == 'b' E dst[2] == 'c' E dst[3] == '\0');
EXIGE(bg_copia_texto(dst, 3, "abc") == false); /* 1 byte a menos */
EXIGE(dst[0] == '\0');
EXIGE(bg_copia_texto(dst, 4, NULL) == true);
EXIGE(dst[0] == '\0');
EXIGE(bg_copia_texto(dst, 0, "abc") == false);
EXIGE(bg_copia_texto(NULL, 4, "abc") == false);
EXIGE(bg_copia_texto(dst, 4, dst) == true); /* origem == destino */
}
Linhas 54–68 · abrir contexto
char sobreposto[8] = "abcd";
EXIGE(bg_junta_texto(dst, 7, "abc", "def") == true); /* 6 + NUL */
EXIGE(strcmp(dst, "abcdef") == 0);
EXIGE(bg_junta_texto(dst, 6, "abc", "def") == false);
EXIGE(dst[0] == '\0');
EXIGE(bg_junta_texto(dst, 7, NULL, "def") == true);
EXIGE(strcmp(dst, "def") == 0);
EXIGE(bg_junta_texto(dst, 7, NULL, NULL) == true);
EXIGE(strcmp(dst, "") == 0);
/* destino sobreposto às próprias origens */
EXIGE(bg_junta_texto(sobreposto, TAMANHO_DE(sobreposto), sobreposto, "xy") == true);
EXIGE(strcmp(sobreposto, "abcdxy") == 0);
}
Linhas 72–115 · abrir contexto
char trecho[4];
EXIGE(bg_acrescenta_texto(dst, 6, "cde") == true); /* 5 + NUL */
EXIGE(strcmp(dst, "abcde") == 0);
EXIGE(bg_acrescenta_texto(dst, 6, "f") == false);
EXIGE(dst[0] == '\0');
EXIGE(bg_acrescenta_texto(dst, 6, NULL) == true);
EXIGE(bg_acrescenta_texto(dst, 1, "") == true); /* só cabe o NUL */
EXIGE(dst[0] == '\0');
EXIGE(bg_trecho_texto(trecho, 4, "abcdef", 2, 3) == true);
EXIGE(strcmp(trecho, "cde") == 0);
/* quantidade é limitada ao fim do texto: 4 bytes não cabem em 4+1? */
EXIGE(bg_trecho_texto(trecho, 4, "abcdef", 2, 99) == false);
EXIGE(trecho[0] == '\0');
{
char t5[5];
EXIGE(bg_trecho_texto(t5, 5, "abcdef", 2, 99) == true);
EXIGE(strcmp(t5, "cdef") == 0);
EXIGE(bg_trecho_texto(t5, 5, "abc", 0, 99) == true);
EXIGE(strcmp(t5, "abc") == 0);
}
EXIGE(bg_trecho_texto(trecho, 4, "abcdef", 6, 1) == true); /* além do fim */
EXIGE(strcmp(trecho, "") == 0);
EXIGE(bg_trecho_texto(trecho, 3, "abcdef", 0, 3) == false); /* não cabe */
EXIGE(bg_trecho_texto(trecho, 4, NULL, 0, 1) == true);
EXIGE(bg_trecho_texto(trecho, 4, "abcd", 0, 0) == true);
EXIGE(strcmp(trecho, "") == 0);
}
/* ----------------------------------------------- texto: comparação */
EXIGE(bg_compara_texto("abc", "abc") == 0);
EXIGE(bg_compara_texto("abc", "abd") == -1);
EXIGE(bg_compara_texto("abd", "abc") == 1);
EXIGE(bg_compara_texto("", "a") == -1);
EXIGE(bg_compara_texto(NULL, NULL) == 0);
EXIGE(bg_compara_texto(NULL, "") == 0);
EXIGE(bg_compara_texto(NULL, "a") == -1);
EXIGE(bg_texto_vazio(NULL) == true);
EXIGE(bg_texto_vazio("") == true);
EXIGE(bg_texto_vazio(" ") == false);
/* -------------------------------------------- texto: formatação */
Linhas 117–132 · abrir contexto
char dst[8];
EXIGE(bg_formata_texto(dst, 4, "%d", 123) == true); /* 3 + NUL */
EXIGE(strcmp(dst, "123") == 0);
EXIGE(bg_formata_texto(dst, 3, "%d", 123) == false); /* truncaria */
EXIGE(dst[0] == '\0');
EXIGE(bg_formata_texto(dst, 8, "%s", "abcdefg") == true);
EXIGE(strcmp(dst, "abcdefg") == 0);
EXIGE(bg_formata_texto(dst, 8, "%s", "abcdefgh") == false);
EXIGE(dst[0] == '\0');
EXIGE(bg_formata_texto(dst, 8, NULL) == false);
EXIGE(bg_formata_texto(NULL, 8, "%d", 1) == false);
EXIGE(bg_formata_texto(dst, 1, "%s", "") == true); /* só o NUL */
EXIGE(dst[0] == '\0');
}
Linhas 135–167 · abrir contexto
int i = 999;
EXIGE(bg_texto_para_inteiro("42", &i) == true E i == 42);
EXIGE(bg_texto_para_inteiro(" -42 ", &i) == true E i == -42);
EXIGE(bg_texto_para_inteiro("+42", &i) == true E i == 42);
EXIGE(bg_texto_para_inteiro("0", &i) == true E i == 0);
EXIGE(bg_texto_para_inteiro("", &i) == false);
EXIGE(bg_texto_para_inteiro(" ", &i) == false);
EXIGE(bg_texto_para_inteiro("42x", &i) == false);
EXIGE(bg_texto_para_inteiro("0x10", &i) == false); /* base 10 */
EXIGE(bg_texto_para_inteiro("1e3", &i) == false);
i = 7;
EXIGE(bg_texto_para_inteiro("nao", &i) == false E i == 7);
EXIGE(bg_texto_para_inteiro(NULL, &i) == false);
EXIGE(bg_texto_para_inteiro("1", NULL) == false);
EXIGE(bg_texto_para_inteiro("2147483647", &i) == true E i == 2147483647);
EXIGE(bg_texto_para_inteiro("-2147483648", &i) == true E i == -2147483647 - 1);
EXIGE(bg_texto_para_inteiro("2147483648", &i) == false); /* +1 */
EXIGE(bg_texto_para_inteiro("-2147483649", &i) == false); /* -1 */
EXIGE(bg_texto_para_inteiro("99999999999999999999", &i) == false);
}
{
unsigned u = 999u;
EXIGE(bg_texto_para_natural("0", &u) == true E u == 0u);
EXIGE(bg_texto_para_natural("4294967295", &u) == true E u == 4294967295u);
EXIGE(bg_texto_para_natural("4294967296", &u) == false); /* +1 */
EXIGE(bg_texto_para_natural("-1", &u) == false); /* sinal */
EXIGE(bg_texto_para_natural(" 7 ", &u) == true E u == 7u);
EXIGE(bg_texto_para_natural("7.0", &u) == false);
}
5 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 EXIGE. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.
Em uma frase, o que EXIGE faz?
Conta a verificação antes de avaliar, para o número final dizer quantas
Para que exatamente EXIGE expande?
O pré-processador substitui EXIGE pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.
Parâmetros formais: cond.
do { \
verificacoes++; \
AFIRME((cond), "verificacao de fronteira falhou"); \
} while (0)
Como EXIGE aparece em código real deste repositório?
Uso extraído de tests/portabilidade/fronteira.c:29, com as linhas vizinhas preservadas:
INICIO
/* ------------------------------------------------ texto: tamanho */
EXIGE(bg_tamanho_texto(NULL) == 0);
EXIGE(bg_tamanho_texto("") == 0);
EXIGE(bg_tamanho_texto("abc") == 3);
Onde EXIGE é exercitado nos testes?
Há 176 ocorrência(s) em 1 arquivo(s): tests/portabilidade/fronteira.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.
EXIGE depende de compilador, padrão C ou sistema operacional?
EXIGE é 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.
O que acontece em caso de falha ou uso inválido?
Não há ressalva editorial específica para este nome. O comportamento em falha é o do corpo/expansão mostrado acima; não invente validação que o fonte não faz.