// 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; }