Pular para o conteúdo principal

BG_AFIRME · AFIRME

Página gerada do fonte

Gerada por tools/gerar_documentacao.py. Definição: include/basicgol.h:244.

Avalia uma condição e emite erro fatal se ela for falsa.

Tipo: macro com argumentos · Módulo/categoria: Entrada e saída.

Nomes equivalentes: AFIRME. Os testes de qualquer um desses nomes são reunidos nesta página.

Assinatura e expansão​

#define BG_AFIRME(c, msg) ((c) ? (void) 0 : bg_erro(__FILE__, __LINE__, (msg)))

Parâmetros formais: c, msg.

Corpo da macro:

((c) ? (void) 0 : bg_erro(__FILE__, __LINE__, (msg)))

Como funciona​

Usa ((c) ? (void)0 : bg_erro(...)); não é a macro assert da libc e não é desligada por NDEBUG.

Contrato e armadilhas
  • A mensagem é avaliada apenas no ramo de falha da expressão condicional.

Nomes internos referenciados: bg_erro.

Como este símbolo aparece nos testes​

66 ocorrência(s) em 8 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/casos/05_entrada_saida/i13_afirme_ok/programa.c​

Contexto: i13_afirme_ok. Linhas: 6. Tipo de evidência: código; via AFIRME.

Linhas 4–8 · abrir contexto
INICIO
INTEIRO total = 10;
AFIRME(total > 0, "total deve ser positivo");
ESCREVAL("contrato ok");
FIM

Ver no GitHub

tests/casos/05_entrada_saida/i14_afirme_dispara/programa.c​

Contexto: i14_afirme_dispara. Linhas: 7. Tipo de evidência: código; via AFIRME.

Linhas 5–9 · abrir contexto
INTEIRO total = -1;
ESCREVAL("comecando");
AFIRME(total > 0, "total deve ser positivo");
ESCREVAL("nunca");
FIM

Ver no GitHub

tests/casos/08_aplicacao/app_acervo/acervo.c​

Contexto: app_acervo. Linhas: 139, 144, 149, 154, 159. Tipo de evidência: código; via AFIRME.

Linhas 137–161 · abrir contexto

FUNCAO INTEIRO acervo_id(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].id;
}

FUNCAO TEXTO acervo_titulo(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].titulo;
}

FUNCAO TEXTO acervo_autor(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].autor;
}

FUNCAO INTEIRO acervo_ano(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].ano;
}

FUNCAO Situacao acervo_situacao(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].situacao;
}

Ver no GitHub

tests/casos/08_aplicacao/app_acervo/principal.c​

Contexto: app_acervo. Linhas: 118. Tipo de evidência: código; via AFIRME.

Linhas 116–119 · abrir contexto
ESCREVA_FMT("fim: %d livro(s), %d emprestado(s), %d recusa(s)\n",
quantidade(), emprestados(), recusados);
AFIRME(quantidade() > 0, "o acervo nao pode terminar vazio");
FIM

Ver no GitHub

tests/portabilidade/cabecalhos_principal.c​

Contexto: cabecalhos_principal.c. Linhas: 30, 31, 32. Tipo de evidência: código; via AFIRME.

Linhas 28–34 · abrir contexto
INTEIRO c = bg_tu3_resultado();

AFIRME(a == 7, "TU1 (inclusao multipla) devolveu 7");
AFIRME(b == 8, "TU2 (extensoes) devolveu 8");
AFIRME(c == 7, "TU3 (BG_SEM_APELIDOS) devolveu 7");

ESCREVA_FMT("cabecalhos: ok (%d %d %d)\n", a, b, c);

Ver no GitHub

tests/portabilidade/controle.c​

Contexto: controle.c. Linhas: 28, 34, 42, 49, 55, 61, 69, 75, 87, 88, 96, 114, 124, 142, 155, 163, 180, 190, 207. Tipo de evidência: código; via AFIRME.

Linhas 26–30 · abrir contexto
total = total + i;
}
AFIRME(total == 6, "PARA (i,1,3) soma 6");

total = 0;

Ver no GitHub

Linhas 32–36 · abrir contexto
total = total + 1; /* limite menor que o início: 0 voltas */
}
AFIRME(total == 0, "PARA (i,3,1) não itera");

total = 0;

Ver no GitHub

Linhas 40–44 · abrir contexto
}
}
AFIRME(total == 9, "PARA aninhado conta 3x3");

/* ---------------------------------------------- PARA_PASSO e passo */

Ver no GitHub

Linhas 47–51 · abrir contexto
total = total + i;
}
AFIRME(total == 6, "PARA_PASSO(0..4, 2) soma 0+2+4");

total = 0;

Ver no GitHub

Linhas 53–57 · abrir contexto
total = total + i;
}
AFIRME(total == 6, "PARA_PASSO(4..0, -2) soma 4+2+0");

total = 0;

Ver no GitHub

Linhas 59–63 · abrir contexto
total = total + 1;
}
AFIRME(total == 1, "PARA_PASSO de um passo só");

/* ------------------------------------------- ENQUANTO com vírgula */

Ver no GitHub

12 outros blocos de contexto: use os links de linha e o JSON de inventário.

tests/portabilidade/fronteira.c​

Contexto: EXIGE. Linhas: 24. Tipo de evidência: código; via AFIRME.

Linhas 22–26 · abrir contexto
* asserções este arquivo tem (serve de alarme se alguém apagar uma). */
#define EXIGE(cond) \
do { \
verificacoes++; \
AFIRME((cond), "verificacao de fronteira falhou"); \

Ver no GitHub

tests/portabilidade/precedencia.c​

Contexto: precedencia.c. Linhas: 33, 34, 35, 36, 37, 38, 39, 40, 41, 49, 50, 51, 53, 54, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 81, 84, 85, 86, 87, 91, 93, 95. Tipo de evidência: código; via AFIRME.

Linhas 31–43 · abrir contexto

/* ---------------------------------------------------- aritmética */
AFIRME(a + b * c == 14, "a + b * c deve ser 14");
AFIRME((a + b) * c == 20, "(a + b) * c deve ser 20");
AFIRME(10 MOD 3 * 2 == 2, "10 MOD 3 * 2 deve ser 2 (MOD antes de *)");
AFIRME(2 + 10 MOD 3 == 3, "2 + 10 MOD 3 deve ser 3");
AFIRME(-7 / 2 == -3, "-7 / 2 trunca em direção a zero");
AFIRME(-7 MOD 2 == -1, "-7 MOD 2 tem o sinal do dividendo");
AFIRME(-2 * -3 == 6, "menos com menos");
AFIRME((!(a - b)) == 0, "operador C ! convive com NAO");
AFIRME((NAO (a - b)) == 0, "NAO (a - b) também");

/* -------------------------------------------------------- lógica */

Ver no GitHub

Linhas 47–72 · abrir contexto
AFIRME(((x E y) OU x) == VERDADEIRO, "(x E y) OU x");
AFIRME((((NAO y) E x) OU y) == VERDADEIRO, "((NAO y) E x) OU y");
AFIRME(((a < b) E (b < c)) == VERDADEIRO, "comparações com E");
AFIRME((IGUAL(a + b, 5)) == VERDADEIRO, "IGUAL com expressão");
AFIRME((DIFERENTE(soma(a, b), a + b)) == FALSO, "DIFERENTE com chamada");
AFIRME((NAO IGUAL(a, b)) == VERDADEIRO, "NAO sobre IGUAL");
AFIRME((OU_EXCLUSIVO(x, y)) == VERDADEIRO, "OU_EXCLUSIVO(1,0)");
AFIRME((LOGICO_DE(0.5)) == VERDADEIRO, "LOGICO_DE(0.5)");
AFIRME((NAO LOGICO_DE(0.0)) == VERDADEIRO, "LOGICO_DE(0.0) normaliza");

/* -------------------------------------- macros aninhadas (C-04) */
AFIRME(MAXIMO(soma(a, b), 7) == 7, "MAXIMO(chamada_com_virgula, 7)");
AFIRME(MINIMO(soma(a, b), MAXIMO(a, c)) == 4, "MINIMO aninhado com MAXIMO");
AFIRME(ABS(MINIMO(a - 10, 0)) == 8, "ABS(MINIMO(...))");
AFIRME(DIVIDE(soma(a, b), a) == 2, "DIVIDE com chamada e divisão truncada");
AFIRME(RESTO(soma(a, b) * 2, c) == 2, "RESTO(10, 4)");
AFIRME(ABS(DIVIDE(RESTO(17, 5), 2)) == 1, "três macros aninhadas");
AFIRME(POTENCIA(2, 3) + 1 == 9, "POTENCIA antes de +");
AFIRME(ARREDONDA(2.5) == 3, "ARREDONDA(2.5) afasta do zero");
AFIRME(ARREDONDA(-2.5) == -3, "ARREDONDA(-2.5) afasta do zero");
AFIRME(TAMANHO_VETOR(v) * 2 == 6, "TAMANHO_VETOR em expressão");
AFIRME(BITS_DE(CARACTERE) == 8, "BITS_DE(CARACTERE)");
AFIRME(TAMANHO_DE(INTEIRO8) == 1, "TAMANHO_DE(INTEIRO8)");
AFIRME(TEXTOS_IGUAIS("ab", "ab") E (NAO TEXTOS_DIFERENTES("ab", "ab")),
"TEXTOS_IGUAIS/DIFERENTES");

Ver no GitHub

Linhas 79–97 · abrir contexto
ESCREVAL("");
FIM_SE
AFIRME(chamadas == 0, "E/OU fazem curto-circuito");

i = 0;
AFIRME((ABS(++i) == 1) E (i == 1), "ABS avalia o argumento uma vez");
AFIRME((MINIMO(++i, 100) == 2) E (i == 2), "MINIMO avalia cada argumento uma vez");
AFIRME((MAXIMO(++i, 0) == 3) E (i == 3), "MAXIMO avalia cada argumento uma vez");
AFIRME((DIVIDE(++i, 1) == 4) E (i == 4), "DIVIDE avalia cada argumento uma vez");

/* ------------------------------- atribuição e precedência mista */
a = b = 3;
AFIRME((a == 3) E (b == 3), "atribuição encadeada associa à direita");
a += 2 * 3;
AFIRME(a == 9, "+= com produto à direita");
a = (b > 2) ? 10 : 20;
AFIRME(a == 10, "ternário");
AFIRME((x E y) == FALSO, "E devolve 0/1");

Ver no GitHub

Evidência indireta​

Estes símbolos chamam/encaminham para este nome. As referências deles ajudam a rastrear o caminho, mas não substituem um teste específico deste símbolo.

Compiladores, padrão C e sistema operacional​

Condições que envolvem a definição:

  • defined(BASICGOL_H) (fonte)
Não confunda implementação com certificação

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.

Checklist de integração​

  • Compile com C11: o cabeçalho seleciona formatos e divisões com _Generic, e C99/C89 são recusados com mensagem explícita.
  • A forma curta AFIRME e a forma canônica BG_AFIRME são a mesma macro; escolha uma por arquivo para não misturar estilos.
  • Rode make test (ou make test-biblioteca para a biblioteca) antes de integrar.
make
cc -std=c11 -Wall -Wextra -Wformat=2 -I include programa.c \
build/libbasicgol.a -lm -o programa

Perguntas frequentes​

Perguntas reunidas a partir da definição, do contrato editorial e dos testes de BG_AFIRME. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.

Em uma frase, o que BG_AFIRME faz?​

Avalia uma condição e emite erro fatal se ela for falsa.

Para que exatamente BG_AFIRME expande?​

O pré-processador substitui BG_AFIRME pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.

Parâmetros formais: c, msg.

((c) ? (void) 0 : bg_erro(__FILE__, __LINE__, (msg)))

Como BG_AFIRME aparece em código real deste repositório?​

Uso extraído de tests/casos/05_entrada_saida/i13_afirme_ok/programa.c:4, com as linhas vizinhas preservadas:

INICIO
INTEIRO total = 10;
AFIRME(total > 0, "total deve ser positivo");
ESCREVAL("contrato ok");
FIM

Onde BG_AFIRME é exercitado nos testes?​

Há 66 ocorrência(s) em 8 arquivo(s): tests/casos/05_entrada_saida/i13_afirme_ok/programa.c, tests/casos/05_entrada_saida/i14_afirme_dispara/programa.c, tests/casos/08_aplicacao/app_acervo/acervo.c, tests/casos/08_aplicacao/app_acervo/principal.c, tests/portabilidade/cabecalhos_principal.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.

BG_AFIRME depende de compilador, padrão C ou sistema operacional?​

BG_AFIRME exige C11 como o restante da linguagem; largura de tipo, libc e CRT continuam sendo os do alvo.

Quais armadilhas preciso evitar ao usar BG_AFIRME?​

O contrato editorial registra: “A mensagem é avaliada apenas no ramo de falha da expressão condicional.”