GastinelGarde autotests : incident VOL de Rednixxu (C1 a C5, C10)
Tests qui documentent le comportement actuel sans toucher au code de production : plane d'elytres sans drapeau puni au 12e tick (C1), point de retour en l'air (C3), setback sans grace ni remise a zero (C2), 5 setbacks puis expulsion en 850 ms (C5), expulsion rendue a chaque paquet (C4, partie moteur), sauts en l'air espaces non vus (C10). 218 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
937d43d499
révision
bfc8f5719c
3 fichiers modifiés
+340
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,41 @@
|
||||
#!/bin/sh
|
||||
# Autotests GastinelGarde (16/10/2026) : compile et lance les tests dans un conteneur JDK 21 jetable.
|
||||
# Usage (sur cornafserver) : sh ~/staging/garde-cas-limites-1016/autotests.sh
|
||||
# Entrée : ~/staging/garde-cas-limites-1016/garde.tgz (copie du worktree test/cas-limites, sans .git ni build).
|
||||
# Ne touche ni à ~/server-infra ni au conteneur minecraft-neoforge.
|
||||
set -e
|
||||
D="$HOME/staging/garde-cas-limites-1016"
|
||||
cd "$D"
|
||||
rm -rf src-build
|
||||
mkdir src-build
|
||||
tar xzf garde.tgz -C src-build
|
||||
cd src-build
|
||||
sed -i 's/\r$//' gradlew
|
||||
mkdir -p "$HOME/.cache/gastinelclaims-gradle"
|
||||
set +e
|
||||
nice -n 10 docker run --rm --memory 4g --cpus 4 \
|
||||
-u "$(id -u):$(id -g)" \
|
||||
-e GRADLE_USER_HOME=/gradle-home \
|
||||
-v "$HOME/.cache/gastinelclaims-gradle:/gradle-home" \
|
||||
-v "$(pwd):/src" -w /src \
|
||||
eclipse-temurin:21-jdk \
|
||||
sh ./gradlew --no-daemon clean test > "$D/build.log" 2>&1
|
||||
CODE=$?
|
||||
set -e
|
||||
echo "code de sortie gradle : $CODE"
|
||||
grep -E "FAILED|BUILD|error:|tests completed" "$D/build.log" | head -40
|
||||
echo "--- totaux (XML JUnit) ---"
|
||||
T=0; F=0; E=0; S=0
|
||||
for x in build/test-results/test/*.xml; do
|
||||
[ -f "$x" ] || continue
|
||||
l=$(grep -o '<testsuite [^>]*>' "$x" | head -1)
|
||||
t=$(echo "$l" | sed -n 's/.* tests="\([0-9]*\)".*/\1/p'); f=$(echo "$l" | sed -n 's/.* failures="\([0-9]*\)".*/\1/p')
|
||||
e=$(echo "$l" | sed -n 's/.* errors="\([0-9]*\)".*/\1/p'); s=$(echo "$l" | sed -n 's/.* skipped="\([0-9]*\)".*/\1/p')
|
||||
T=$((T+t)); F=$((F+f)); E=$((E+e)); S=$((S+s))
|
||||
case "$x" in *Autotest*) echo "$(basename "$x") tests=$t echecs=$f erreurs=$e ignores=$s";; esac
|
||||
done
|
||||
echo "TOTAL tests=$T echecs=$F erreurs=$E ignores=$S"
|
||||
echo "--- mesures ---"
|
||||
cat build/minecraft-junit/build/autotests-mesures.txt build/autotests-mesures.txt 2>/dev/null || true
|
||||
echo "--- echecs detailles ---"
|
||||
for x in build/test-results/test/*.xml; do grep -A6 '<failure' "$x" 2>/dev/null | head -30; done | head -120
|
||||
@@ -0,0 +1,272 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
|
||||
*
|
||||
* Ces tests DOCUMENTENT le comportement actuel, ils ne corrigent rien : un test nommé {@code FAILLE_…} ou
|
||||
* {@code FAUX_POSITIF_…} passe tant que le défaut existe. Quand le défaut sera corrigé, il échouera : il faudra alors
|
||||
* inverser son assertion (c'est voulu, pour que la correction soit vue).
|
||||
*
|
||||
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
|
||||
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
|
||||
* teleport() non mesuré (Garde.teleportVanilla remet mouvementTick à zéro).
|
||||
*/
|
||||
class AutotestVolIncidentTest {
|
||||
|
||||
private static final double Y_SOL = 110.875;
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private int tick;
|
||||
private double y;
|
||||
/** Modèle de Garde.apresMouvement : dernière position mémorisée (y) et si elle était au sol serveur. */
|
||||
private double yRetour;
|
||||
private boolean retourAuSol;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE); // mode en production le 15/10 (rapport des journaux)
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 37_000;
|
||||
y = Y_SOL;
|
||||
yRetour = Y_SOL;
|
||||
retourAuSol = true;
|
||||
}
|
||||
|
||||
static EtatMouvement air(double dy) {
|
||||
return new EtatMouvement(0.1, dy, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
static EtatMouvement sol() {
|
||||
return new EtatMouvement(0.1, 0, 1, true, true, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
static double points(List<Verdict> vs, Controle c) {
|
||||
double p = 0;
|
||||
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Un paquet accepté, avec le modèle de mémorisation de la position de retour. */
|
||||
private List<Verdict> paquet(EtatJoueur e, EtatMouvement m) {
|
||||
tick++;
|
||||
y += m.dy();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
|
||||
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
|
||||
yRetour = y;
|
||||
retourAuSol = m.auSolServeur();
|
||||
}
|
||||
return vs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trace de Rednixxu (rapport des journaux, ticks 37 589 à 37 614) : au sol à y = 110,875, saut, drapeau élytres
|
||||
* pendant 7 ticks, drapeau retombé alors que le client plane encore (accélération ~0,02 bloc/tick² au lieu de 0,08).
|
||||
*
|
||||
* @return verdicts de chaque paquet de plané sans drapeau
|
||||
*/
|
||||
private List<List<Verdict>> sautPuisPlaneSansDrapeau(int ticksPlane) {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double v = 0.42;
|
||||
for (int i = 0; i < 5; i++) { // saut normal
|
||||
paquet(EtatJoueur.normal(), air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05)); // drapeau 16 : exempté
|
||||
List<List<Verdict>> sortie = new ArrayList<>();
|
||||
for (int k = 1; k <= ticksPlane; k++) sortie.add(paquet(EtatJoueur.normal(), air(-0.02 * k)));
|
||||
return sortie;
|
||||
}
|
||||
|
||||
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int premier = -1;
|
||||
double total = 0;
|
||||
for (int k = 0; k < vs.size(); k++) {
|
||||
double p = points(vs.get(k), Controle.VOL);
|
||||
if (p > 0 && premier < 0) premier = k + 1;
|
||||
total += p;
|
||||
}
|
||||
// Prouvé : le 1er paquet après l'exemption sert de référence, les suivants sont tous « anormaux » ; le 12e tick
|
||||
// de plané sans drapeau donne le premier point (journal réel : 13 ticks après la chute du drapeau, vl=1.1).
|
||||
assertEquals(12, premier, "premier tick de plané puni");
|
||||
assertEquals(1.1, points(vs.get(11), Controle.VOL), 1e-9);
|
||||
assertTrue(total > cfg.seuilSetback, "19 ticks de plané suffisent à dépasser le seuil de setback");
|
||||
Mesures.noter("C1 premier point au tick " + premier + " de plane sans drapeau ; total 19 ticks = " + total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_finDElytresSuivieDUneVraieChuteNeDonneRien() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 40; i++) paquet(elytres, air(-0.5));
|
||||
double v = -0.5, total = 0;
|
||||
for (int i = 0; i < 60; i++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
|
||||
}
|
||||
|
||||
// --- C3 : point de retour mémorisé en l'air -----------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C3_pointDeRetourMemoriseEnLAirSousLaPlateforme() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(12);
|
||||
assertTrue(points(vs.get(11), Controle.VOL) > 0);
|
||||
assertFalse(retourAuSol, "la position de retour vient d'un paquet en l'air");
|
||||
assertTrue(yRetour < Y_SOL, "et elle est sous la plateforme d'où il a sauté : " + yRetour);
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT,
|
||||
"C3 retour en l'air a y=%.3f (sol %.3f, ecart %.3f ; journal reel : 109,685, ecart 1,19)",
|
||||
yRetour, Y_SOL, Y_SOL - yRetour));
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
int premier = -1;
|
||||
for (int k = 1; k <= 15 && premier < 0; k++) {
|
||||
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
|
||||
}
|
||||
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
|
||||
assertFalse(retourAuSol);
|
||||
assertTrue(yRetour - Y_SOL >= 0.9, "le setback ramène à l'altitude gagnée en volant : +" + (yRetour - Y_SOL));
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C3 tricheur : retour a +%.2f bloc au-dessus du sol",
|
||||
yRetour - Y_SOL));
|
||||
}
|
||||
|
||||
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C2_setbackNOuvreAucuneGraceEtNeRemetPasLeVolAZero() {
|
||||
GraceTeleport g = new GraceTeleport();
|
||||
g.annoncer(GraceTeleport.Origine.SETBACK);
|
||||
assertFalse(g.teleport(), "le setback n'ouvre pas la grâce de téléportation");
|
||||
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int k = 0;
|
||||
while (Verdict.pire(vs.get(k)) != Sanction.SETBACK) k++; // premier SETBACK
|
||||
// Modèle de l'adaptateur : teleport() vers le point de retour ; le paquet suivant n'est pas mesuré.
|
||||
tick++;
|
||||
y = yRetour;
|
||||
// Joueur gelé en l'air au point de retour (dy = 0, gravité absente tant que la téléportation n'est pas
|
||||
// confirmée : « kicked for floating too long » x302 dans le journal du 15/10).
|
||||
for (int i = 0; i < 5; i++) {
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), air(0));
|
||||
assertTrue(points(v, Controle.VOL) > 0, "paquet gelé " + i + " après le setback encore puni");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C5_C4_cinqSetbacksPuisExpulsionEnMoinsDUneSecondeEtExpulsionRepetee() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double v = 0.42;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
paquet(EtatJoueur.normal(), air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05));
|
||||
|
||||
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
|
||||
double dyPlane = 0;
|
||||
boolean gele = false;
|
||||
for (int n = 0; n < 200 && expulsionTick < 0; n++) {
|
||||
EtatMouvement m;
|
||||
if (gele) {
|
||||
m = air(0);
|
||||
} else {
|
||||
dyPlane -= 0.02;
|
||||
m = air(dyPlane);
|
||||
}
|
||||
List<Verdict> vs = paquet(EtatJoueur.normal(), m);
|
||||
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
|
||||
Sanction s = Verdict.pire(vs);
|
||||
if (s == Sanction.SETBACK) {
|
||||
setbacks++;
|
||||
gele = true;
|
||||
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||
y = yRetour;
|
||||
} else if (s == Sanction.EXPULSION) {
|
||||
expulsionTick = tick;
|
||||
}
|
||||
}
|
||||
assertTrue(expulsionTick > 0, "expulsion atteinte");
|
||||
int duree = expulsionTick - premierPointTick;
|
||||
Mesures.noter("C5 premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), " + setbacks
|
||||
+ " setbacks (journal reel : 5 setbacks, expulsion a la 1re seconde)");
|
||||
assertTrue(duree < 20, "moins d'une seconde entre le premier point et l'expulsion : " + duree + " ticks");
|
||||
assertTrue(setbacks >= 3 && setbacks <= 6, "quelques setbacks seulement : " + setbacks);
|
||||
|
||||
// C4 (partie moteur) : rien ne retient « déjà expulsé » ; chaque paquet suivant redonne une EXPULSION.
|
||||
int expulsionsSuivantes = 0;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
if (Verdict.pire(paquet(EtatJoueur.normal(), air(0))) == Sanction.EXPULSION) expulsionsSuivantes++;
|
||||
}
|
||||
assertEquals(20, expulsionsSuivantes, "chaque paquet après l'expulsion rend encore EXPULSION");
|
||||
}
|
||||
|
||||
@Test
|
||||
void referenceEnObserveLeMemeIncidentNeToucheJamaisLeJoueur() {
|
||||
cfg.mode(Controle.VOL, Mode.OBSERVE);
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(40);
|
||||
for (List<Verdict> v : vs) {
|
||||
assertNotEquals(Sanction.SETBACK, Verdict.pire(v));
|
||||
assertNotEquals(Sanction.EXPULSION, Verdict.pire(v));
|
||||
}
|
||||
}
|
||||
|
||||
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
for (int cycle = 0; cycle < 30; cycle++) {
|
||||
double v = 0.42; // « saut » en plein air
|
||||
for (int i = 0; i < 10; i++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "prouvé : aucun point");
|
||||
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite.
|
||||
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
for (int i = 0; i < 200; i++) {
|
||||
// tick pair : plané (dy = -0,02, anormal) ; tick impair : la vraie gravité depuis ce plané (normal)
|
||||
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
|
||||
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026 : note les valeurs mesurées par les tests (nombre de paquets avant expulsion, altitude du
|
||||
* point de retour…) dans build/autotests-mesures.txt, pour le rapport. N'influence aucun résultat.
|
||||
*/
|
||||
final class Mesures {
|
||||
|
||||
private Mesures() { }
|
||||
|
||||
static void noter(String ligne) {
|
||||
try {
|
||||
Path p = Path.of("build", "autotests-mesures.txt");
|
||||
Files.createDirectories(p.getParent());
|
||||
Files.writeString(p, ligne + System.lineSeparator(), StandardCharsets.UTF_8,
|
||||
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
|
||||
} catch (IOException | RuntimeException ignored) {
|
||||
// mesure facultative
|
||||
}
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur