Pular para o conteúdo principal

ok

Página gerada do fonte

Gerada por tools/gerar_documentacao.py. Definição: tests/run_checkout_limpo.sh:34.

Conta aprovação nos runners auxiliares.

Tipo: função Shell · Visibilidade: pública · Arquivo: tests/run_checkout_limpo.sh.

Assinatura e expansão​

ok()

Como funciona​

Incrementa o contador local e imprime a linha de aprovação conforme o modo verboso do script.

Implementação​

ok() {
OK=$((OK + 1))
[ "$VERBOSO" = 1 ] && printf ' ok %s\n' "$1"
return 0
}

Como este símbolo aparece nos testes​

64 ocorrência(s) em 7 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/02_basico/b03_real/programa.c​

Contexto: b03_real. Linhas: 20. Tipo de evidência: código; via ok.

Linhas 18–22 · abrir contexto
// 0.1 + 0.2 != 0.3 em binario: a comparacao correta usa tolerancia
SE perto(0.1 + 0.2, 0.3, 1e-9) ENTAO
ESCREVAL("soma ok");
SENAO
ESCREVAL("soma estranha");

Ver no GitHub

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

Contexto: i09_texto_truncamento. Linhas: 8, 10, 11, 14, 15, 18, 19, 20, 21. Tipo de evidência: código; via ok.

Linhas 6–23 · abrir contexto
TEXTO_FIXO(a, 4);
TEXTO_FIXO(b, 8);
LOGICO ok = FALSO;

ok = COPIA_TEXTO(a, (INTEIRO) sizeof a, "abcdef");
ESCREVAL(ok); // 0
ESCREVAL(TAMANHO_TEXTO(a)); // 0 (destino vazio)

ok = COPIA_TEXTO(a, (INTEIRO) sizeof a, "abc");
ESCREVAL(ok); // 1
ESCREVAL(a);

ok = JUNTA_TEXTO(b, (INTEIRO) sizeof b, "abcd", "efgh");
ESCREVAL(ok); // 0
ok = JUNTA_TEXTO(b, (INTEIRO) sizeof b, "abc", "de");
ESCREVAL(ok); // 1
ESCREVAL(b);
FIM

Ver no GitHub

tests/fuzz_basicgolc.py​

Contexto: main. Linhas: 154, 173. Tipo de evidência: código; via ok.

Linhas 152–156 · abrir contexto

falhas = 0
ok = 0
por_mutacao: dict[str, int] = {}

Ver no GitHub

Linhas 171–175 · abrir contexto
print(f" entrada preservada em {destino.relative_to(RAIZ)}")
else:
ok += 1
if args.verboso:
print(f" ok {n} ({nome}) rc={rc}")

Ver no GitHub

tests/portabilidade/entrada.c​

Contexto: entrada.c. Linhas: 19, 22, 23, 26, 27, 31, 32, 35, 36, 44, 45, 48, 49, 57, 58, 61, 62, 65, 66, 70, 71, 72, 73. Tipo de evidência: código; via ok.

Linhas 17–38 · abrir contexto
TEXTO_FIXO(linha, 32);
TEXTO_FIXO(curto, 4);
LOGICO ok;

/* 1. número válido: LEIA_OK devolve verdadeiro */
ok = LEIA_OK(n);
ESCREVA_FMT("1 ok=%d n=%d\n", (int) ok, n);

/* 2. LEIA_TEXTO depois de LEIA consome o \n pendente e lê a linha seguinte */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("2 ok=%d linha=[%s]\n", (int) ok, linha);

/* 3. texto onde se esperava número: falha e o destino NÃO muda */
n = 123;
ok = LEIA_OK(n);
ESCREVA_FMT("3 ok=%d n=%d\n", (int) ok, n);

/* 4. recuperação: a linha inválida continua no fluxo e é consumida aqui */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("4 ok=%d linha=[%s]\n", (int) ok, linha);

/* 5. LEIA (scanf) lê o número e deixa o resto da linha no fluxo */

Ver no GitHub

Linhas 42–51 · abrir contexto

/* 6. o resto da linha é lido como texto, com o espaço à frente */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("6 ok=%d linha=[%s]\n", (int) ok, linha);

/* 7. LEIA_REAL */
ok = LEIA_REAL(r);
ESCREVA_FMT("7 ok=%d r=%g\n", (int) ok, r);

/* 8. LEIA de CARACTERE depois de uma leitura numérica (i15) */

Ver no GitHub

Linhas 55–75 · abrir contexto
/* 9. LEIA_INTEIRO com lixo depois dos dígitos: recusa a linha inteira */
n = 77;
ok = LEIA_INTEIRO(n);
ESCREVA_FMT("9 ok=%d n=%d\n", (int) ok, n);

/* 10. LEIA_TEXTO com buffer pequeno: falha, destino vazio, resto consumido */
ok = LEIA_TEXTO(curto, TAMANHO_DE(curto));
ESCREVA_FMT("10 ok=%d curto=[%s]\n", (int) ok, curto);

/* 11. e o fluxo continua sincronizado na linha seguinte */
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("11 ok=%d linha=[%s]\n", (int) ok, linha);

/* 12. EOF: falha em vez de repetir a última leitura */
n = 5;
ok = LEIA_TEXTO(linha, TAMANHO_DE(linha));
ESCREVA_FMT("12 ok=%d linha=[%s]\n", (int) ok, linha);
ok = LEIA_INTEIRO(n);
ESCREVA_FMT("13 ok=%d n=%d\n", (int) ok, n);
LEIA(n);
ESCREVA_FMT("14 n=%d\n", n);

Ver no GitHub

tests/run_checkout_limpo.sh​

Contexto: roda, run_checkout_limpo.sh. Linhas: 56, 66, 72, 91, 101, 111. Tipo de evidência: código; via ok.

Linhas 54–58 · abrir contexto

if [ -f "$DEST/Makefile" ] && [ -f "$DEST/include/basicgol.h" ]; then
ok "checkout limpo montado ($(find "$DEST" -type f | wc -l) arquivos, sem build/)"
else
echo "run_checkout_limpo.sh: não consegui montar o checkout em $DEST" >&2

Ver no GitHub

Linhas 64–68 · abrir contexto
falhou "o checkout limpo não deveria conter diretórios de build"
else
ok "nenhum artefato de build veio junto"
fi

Ver no GitHub

Linhas 70–74 · abrir contexto
local rotulo="$1"; shift
if "$@" > "$TMP/saida.log" 2>&1; then
ok "$rotulo"
else
falhou "$rotulo" "$(tail -5 "$TMP/saida.log" | tr '\n' ' ')"

Ver no GitHub

Linhas 89–93 · abrir contexto
# o arquivo gerado tem de ser idêntico ao versionado.
if cmp -s "$TMP/COBERTURA.antes.md" "$DEST/tests/COBERTURA.md"; then
ok "make cobertura não altera tests/COBERTURA.md (checagem do CI)"
else
falhou "make cobertura alterou tests/COBERTURA.md" \

Ver no GitHub

Linhas 99–103 · abrir contexto
docs/exemplos/ola_mundo.c build/libbasicgol.a -lm -o ola_m0 \
> "$TMP/m0.log" 2>&1 && [ "$(./ola_m0)" = "Ola, mundo!" ] ); then
ok "comando M0 de uma linha do README compila e imprime 'Ola, mundo!'"
else
falhou "comando M0 de uma linha" "$(tail -4 "$TMP/m0.log" | tr '\n' ' ')"

Ver no GitHub

Linhas 109–113 · abrir contexto
&& ${CC:-cc} -std=c11 -Wall -Wextra -I include /tmp/gerado.c \
build/libbasicgol.a -lm -o /tmp/gerado_m1 >> "$TMP/m1.log" 2>&1 ); then
ok "fluxo M1 de duas etapas do README (transpila e compila o C gerado)"
else
falhou "fluxo M1 de duas etapas" "$(tail -4 "$TMP/m1.log" | tr '\n' ' ')"

Ver no GitHub

tests/run_msvc.sh​

Contexto: confere_saida. Linhas: 130. Tipo de evidência: código; via ok.

Linhas 128–132 · abrir contexto
fi
fi
ok "$nome ($rotulo)"
}

Ver no GitHub

tests/run_portabilidade.sh​

Contexto: run_portabilidade.sh. Linhas: 220, 231, 239, 247, 268, 280, 293, 307, 331, 350, 376, 403, 424, 435, 456, 469, 490, 498, 511, 516, 522, 527. Tipo de evidência: código; via ok.

Linhas 218–222 · abrir contexto
std_efetivo=c23
fi
else
std_efetivo=$std
fi

Ver no GitHub

Linhas 229–233 · abrir contexto
done

# C99 e C89 recusados, com a mensagem da linguagem
printf '#include <basicgol.h>\nint main(void){return 0;}\n' > "$TMP/h99.c"
if tenta "$cc" -std=c99 -I "$INCLUDE" -o "$TMP/h99" "$TMP/h99.c"; then

Ver no GitHub

Linhas 237–241 · abrir contexto
else
falhou "[$i] C99 recusado sem a mensagem esperada" "$(head -2 "$TMP/e" | tr '\n' ' ')"
fi
printf '#include <basicgol.h>\nint main(void){return 0;}\n' > "$TMP/h89.c"
if tenta "$cc" -std=c89 -I "$INCLUDE" -o "$TMP/h89" "$TMP/h89.c"; then

Ver no GitHub

Linhas 245–249 · abrir contexto
fi

# cada cabeçalho público sozinho (autocontido)
for h in basicgol.h basicgol/biblioteca.h basicgol/consola.h basicgol/texto.h \
basicgol/matematica.h basicgol/caractere.h basicgol/utilidades.h; do

Ver no GitHub

Linhas 266–270 · abrir contexto
for prog in precedencia controle fronteira; do
if ! tenta "$cc" -std=c11 $FLAGS_ESTRITAS -I "$INCLUDE" \
-o "$TMP/$prog.$i" "$PORT/$prog.c" "$BIBLIOTECA" -lm; then
falhou "[$i] compilar $prog.c" "$(head -4 "$TMP/e" | tr '\n' ' ')"
continue

Ver no GitHub

Linhas 278–282 · abrir contexto

# M0 × M1 no mesmo fonte de controle de fluxo
if "$FERRAMENTA" "$PORT/controle.c" -o "$TMP/controle.gerado.$i.c" 2> "$TMP/e" \
&& tenta "$cc" -std=c11 $FLAGS_ESTRITAS -I "$INCLUDE" \
-o "$TMP/controle.m1.$i" "$TMP/controle.gerado.$i.c" "$BIBLIOTECA" -lm; then

Ver no GitHub

14 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.

  • Runner Bash: requer Bash e utilitários Unix; no Windows o projeto usa Git Bash/MSYS2. Não é um script CMD/PowerShell.
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.

Perguntas frequentes​

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

Em uma frase, o que ok faz?​

Conta aprovação nos runners auxiliares.

Qual é a assinatura e o tipo de retorno de ok?​

Assinatura extraída de tests/run_checkout_limpo.sh; visibilidade pública.

ok()

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

Uso extraído de tests/casos/02_basico/b03_real/programa.c:18, com as linhas vizinhas preservadas:

// 0.1 + 0.2 != 0.3 em binario: a comparacao correta usa tolerancia
SE perto(0.1 + 0.2, 0.3, 1e-9) ENTAO
ESCREVAL("soma ok");
SENAO
ESCREVAL("soma estranha");

Onde ok é exercitado nos testes?​

Há 64 ocorrência(s) em 7 arquivo(s): tests/casos/02_basico/b03_real/programa.c, tests/casos/05_entrada_saida/i09_texto_truncamento/programa.c, tests/fuzz_basicgolc.py, tests/portabilidade/entrada.c, tests/run_checkout_limpo.sh …. 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.

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

ok é uma função de runner Bash: requer Bash e utilitários Unix; no Windows o projeto usa Git Bash/MSYS2, não CMD/PowerShell.

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.