77 lignes
3.2 KiB
C++
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;
|
|
}
|