Fichiers
2026-10-11 01:55:22 +02:00

77 lignes
3.2 KiB
C++

// test/oracle/selftest_main.cpp — VALIDATION DU HARNAIS LUI-MEME.
//
// « Un harnais qui ne sait pas detecter une erreur connue ne vaut rien. »
//
// Ce programme fait deux passes :
// 1. la paire correcte doit etre ACCEPTEE ;
// 2. la paire volontairement fausse (un octet de decalage) doit etre
// REJETEE, avec un diagnostic exploitable affiche a l ecran.
//
// Il rend 0 seulement si les deux attentes sont satisfaites. Un harnais qui
// accepterait la version fausse ferait echouer ce test, ce qui est le but.
//
// Ce binaire NE LIE PAS proj3_newguard : il doit afficher son diagnostic
// jusqu au bout, et l on ne veut pas qu une allocation de la libc dans printf
// vienne brouiller le resultat du test qui nous interesse ici.
#include "oracle.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace proj3::oracle {
usize fill_bytes_ref(const u8* in, usize in_len, u8* out, usize out_cap);
extern const Pair kBrokenPair;
} // namespace proj3::oracle
extern "C" {
proj3::usize proj3_fill_bytes_asm(const proj3::u8*, proj3::usize, proj3::u8*, proj3::usize);
}
int main() {
err_write("=== self-test du harnais d oracle ===\n\n");
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("impossible d acquerir la memoire de travail\n");
return 1;
}
// --- Passe 1 : la version correcte doit passer -------------------------
err_write("passe 1 : la version assembleur CORRECTE doit etre acceptee\n");
const oracle::Pair good = {"fill_bytes (version correcte)", &oracle::fill_bytes_ref,
&proj3_fill_bytes_asm, oracle::kBrokenPair.cases,
oracle::kBrokenPair.case_count};
oracle::Report rep_good;
const bool good_ok = oracle::run_pair(good, sys.scratch, rep_good, /*expect_failure=*/false);
err_write(good_ok ? " -> acceptee, comme attendu\n\n"
: " -> REJETEE ALORS QU ELLE EST CORRECTE (harnais casse)\n\n");
// --- Passe 2 : la version fausse doit etre rejetee ---------------------
err_write("passe 2 : la version assembleur FAUSSE doit etre rejetee\n");
err_write(" (defaut injecte : un octet de moins ecrit, longueur rendue correcte)\n");
err_write(" le diagnostic ci-dessous est celui que le harnais produirait\n");
err_write(" sur un vrai bug ; c est lui qu on evalue :\n\n");
oracle::Report rep_bad;
const bool bad_ok =
oracle::run_pair(oracle::kBrokenPair, sys.scratch, rep_bad, /*expect_failure=*/true);
err_write("\n");
err_write(bad_ok ? " -> rejetee, comme attendu\n"
: " -> ACCEPTEE ALORS QU ELLE EST FAUSSE (harnais inutile)\n");
err_write(" cas en echec detectes : ");
err_write_i64(rep_bad.cases_failed);
err_write(" / ");
err_write_i64(rep_bad.cases_run);
err_write("\n");
err_write(" (les cas de longueur nulle ne peuvent pas diverger : c est normal\n");
err_write(" qu ils ne comptent pas dans les echecs)\n");
const bool ok = good_ok && bad_ok;
err_write(ok ? "\nRESULTAT : le harnais discrimine correctement\n"
: "\nRESULTAT : LE HARNAIS EST DEFAILLANT\n");
return ok ? 0 : 1;
}