Comparer les révisions

..
1 Révisions
Auteur SHA1 Message Date

2026-10-16

Théo GastineletClaude Opus 5.5 59c51360d2 Autotests adverses GastinelClaims (FAILLE_/FAUX_POSITIF_) et script conteneur
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:57:25 +02:00
2 fichiers modifiés avec 287 ajouts et 0 suppressions

Aucun fichier ne correspond à votre recherche

+40
Voir le fichier
@@ -0,0 +1,40 @@
#!/bin/sh
# Autotests (16/10/2026) : compile et lance les tests dans un conteneur JDK 21 jetable (rien installé sur l'hôte).
# Usage (sur la machine de build) : sh autotests-conteneur.sh <dossier>
# Entrée : <dossier>/src.tgz (copie du worktree test/autotests, sans .git ni build).
# Ne touche à aucun serveur Minecraft ni à son conteneur.
set -e
D="$1"
[ -n "$D" ] && [ -f "$D/src.tgz" ] || { echo "usage : $0 <dossier contenant src.tgz>"; exit 2; }
cd "$D"
rm -rf src-build
mkdir src-build
tar xzf src.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))
echo "$(basename "$x") tests=$t echecs=$f erreurs=$e ignores=$s"
done
echo "TOTAL tests=$T echecs=$F erreurs=$E ignores=$S"
echo "--- echecs detailles ---"
for x in build/test-results/test/*.xml; do grep -A8 '<failure' "$x" 2>/dev/null | head -30; done | head -120
+247
Voir le fichier
@@ -0,0 +1,247 @@
package com.gastinelclaims;
import com.gastinelclaims.core.ChunkKey;
import com.gastinelclaims.core.ClaimRegistry;
import net.neoforged.bus.api.SubscribeEvent;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.*;
/**
* Autotests adverses de GastinelClaims (16/10/2026).
*
* Convention (comme GastinelGarde, branche test/cas-limites) : un test FAILLE_… (contournement) ou
* FAUX_POSITIF_… (joueur honnête puni) PASSE TANT QUE LE DÉFAUT EXISTE. Le jour du correctif, il échoue :
* il faut alors inverser son assertion (il devient un test de non-régression).
*
* Trois sortes de preuves :
* - logique : appel direct de ClaimRegistry (code de production) ;
* - réflexion : liste des méthodes @SubscribeEvent réellement présentes dans les classes du mod
* (prouve l'ABSENCE d'un gestionnaire d'événement) ;
* - hiérarchie de classes Minecraft (chargées sans initialisation).
* Rien ici n'est testé en jeu.
*/
class AutotestClaimsTest {
private static final String OW = "minecraft:overworld";
/** Types d'événements écoutés par une classe du mod (paramètre des méthodes @SubscribeEvent). */
private static List<String> evenementsEcoutes(Class<?> c) {
List<String> out = new ArrayList<>();
for (Method m : c.getDeclaredMethods()) {
if (m.isAnnotationPresent(SubscribeEvent.class) && m.getParameterCount() == 1) {
out.add(m.getParameterTypes()[0].getName());
}
}
return out;
}
private static boolean ecoute(Class<?> c, String fragmentDeNom) {
return evenementsEcoutes(c).stream().anyMatch(n -> n.contains(fragmentDeNom));
}
/** Dossier du projet : le test tourne parfois dans build/minecraft-junit (moddev unitTest). */
private static Path racine() {
Path p = Path.of("").toAbsolutePath();
while (p != null && !Files.isDirectory(p.resolve("src/main/java"))) p = p.getParent();
assertNotNull(p, "dossier du projet introuvable depuis " + Path.of("").toAbsolutePath());
return p;
}
private static String source(String chemin) throws IOException {
return Files.readString(racine().resolve("src/main/java/com/gastinelclaims/" + chemin), StandardCharsets.UTF_8);
}
private static Class<?> classeMc(String nom) throws ClassNotFoundException {
return Class.forName(nom, false, AutotestClaimsTest.class.getClassLoader());
}
// --- Témoin : la réflexion voit bien les gestionnaires existants ---
@Test
void temoin_laReflexionVoitLesGestionnairesExistants() {
assertTrue(ecoute(ProtectionEvents.class, "BlockEvent$BreakEvent"));
assertTrue(ecoute(ProtectionEvents.class, "ExplosionEvent$Detonate"));
// ZoneEvents (spawn) gère bien pistons, liquides et mobs : la comparaison avec les claims est juste.
assertTrue(ecoute(ZoneEvents.class, "PistonEvent$Pre"));
assertTrue(ecoute(ZoneEvents.class, "FluidPlaceBlockEvent"));
assertTrue(ecoute(ZoneEvents.class, "EntityMobGriefingEvent"));
}
// --- C1 : pistons ---
@Test
void FAILLE_C1_aucunControleDePistonPourLesClaims() {
// Un piston (collant) posé HORS du claim, contre sa bordure, pousse ou tire des blocs du claim
// (et pousse des rails, de la lave figée, du TNT… dedans). Seule la zone de spawn est couverte.
for (Class<?> c : List.of(ProtectionEvents.class, ClaimCommands.class)) {
assertFalse(ecoute(c, "PistonEvent"), c.getSimpleName() + " écoute PistonEvent : faille corrigée ?");
}
}
// --- C2 / C3 : liquides et feu ---
@Test
void FAILLE_C2_liquidesVenusDeLExterieurEntrentDansLesClaims() throws IOException {
assertFalse(ecoute(ProtectionEvents.class, "FluidPlaceBlockEvent"));
String mixin = source("mixin/FlowingFluidMixin.java");
assertTrue(mixin.contains("ZonesProtegees.protege"), "témoin : le mixin protège la zone de spawn");
assertFalse(mixin.contains("ClaimsData") || mixin.contains("ClaimRegistry"),
"le mixin des liquides consulte les claims : faille corrigée ?");
}
@Test
void FAILLE_C3_leFeuAllumeDehorsSePropageEtBruleDansLesClaims() throws IOException {
String mixin = source("mixin/FireBlockMixin.java");
assertTrue(mixin.contains("ZonesProtegees.protege"));
assertFalse(mixin.contains("ClaimsData") || mixin.contains("ClaimRegistry"),
"le mixin du feu consulte les claims : faille corrigée ?");
}
// --- C4 : projectiles ---
@Test
void FAILLE_C4_projectilesNonControlesAnimauxCadresSupportsDArmure() {
// AttackEntityEvent ne couvre que le coup au corps à corps. Flèche, trident, boule de neige,
// potion jetable, canne à pêche : rien n'est vérifié pour les entités d'un claim.
for (String e : List.of("ProjectileImpactEvent", "LivingIncomingDamageEvent", "LivingDamageEvent",
"LivingAttackEvent")) {
assertFalse(ecoute(ProtectionEvents.class, e), e + " écouté : faille corrigée ?");
}
}
// --- C5 : mobs ---
@Test
void FAILLE_C5_endermenEtMobsGriefentLesClaims() {
assertFalse(ecoute(ProtectionEvents.class, "EntityMobGriefingEvent"));
assertFalse(ecoute(ProtectionEvents.class, "LivingDestroyBlockEvent"));
}
// --- C6 : FakePlayer (Create deployer) dans le chunk visé ---
@Test
void FAILLE_C6_machineDontLeFakePlayerEstDansLeChunkViseAgitCommeLeProprietaire() {
// Modèle de ProtectionEvents.allowed (branche FakePlayer) : acteur = propriétaire du chunk OÙ EST la
// machine. Si le FakePlayer se trouve dans le chunk visé (déployeur sur une contraption Create qui
// entre dans le claim, ou dont la position du FakePlayer est la case devant lui), l'acteur EST le
// propriétaire : tout est permis. Le calcul ci-dessous est celui du code de production.
ClaimRegistry r = new ClaimRegistry();
UUID victime = UUID.randomUUID();
ChunkKey claim = new ChunkKey(OW, 10, 10);
r.claim(victime, claim, 25);
ChunkKey ouEstLaMachine = claim; // la machine est entrée dans le chunk
UUID acteur = r.ownerOf(ouEstLaMachine);
assertTrue(r.canAccess(acteur, claim, false), "la machine d'un inconnu agit comme la victime");
// Témoin : la même machine restée dehors (chunk libre) est refusée.
assertFalse(r.canAccess(r.ownerOf(new ChunkKey(OW, 11, 10)), claim, false));
}
// --- C7 : piétinement par les mobs ---
@Test
void FAILLE_C7_seulsLesJoueursNePietinentPasLesCultures() throws IOException {
String s = source("ProtectionEvents.java");
assertTrue(s.contains("onTrample(BlockEvent.FarmlandTrampleEvent event)"));
assertTrue(s.contains("if (event.getEntity() instanceof Player p"),
"un mob (ou un joueur sur un cheval/cochon) piétine librement : seul un Player est contrôlé");
}
// --- FP1 : entités « non hostiles » qui attaquent ---
@Test
void FAUX_POSITIF_FP1_impossibleDeSeDefendreContreLoupGolemAbeilleOursDansUnClaim() throws Exception {
// isProtectedEntity(e) = !(e instanceof Enemy) && !(e instanceof Player).
// Ces mobs peuvent attaquer un joueur mais n'implémentent pas Enemy : dans le claim d'un autre,
// le joueur attaqué ne peut pas riposter (coup annulé).
String s = source("ProtectionEvents.java");
assertTrue(s.contains("return !(e instanceof Enemy) && !(e instanceof Player);"));
Class<?> enemy = classeMc("net.minecraft.world.entity.monster.Enemy");
for (String n : List.of("net.minecraft.world.entity.animal.Wolf", "net.minecraft.world.entity.animal.IronGolem",
"net.minecraft.world.entity.animal.Bee", "net.minecraft.world.entity.animal.PolarBear",
"net.minecraft.world.entity.animal.horse.Llama", "net.minecraft.world.entity.animal.goat.Goat")) {
assertFalse(enemy.isAssignableFrom(classeMc(n)), n + " implémente Enemy");
}
// Témoin : un zombie est bien Enemy (attaquable partout).
assertTrue(enemy.isAssignableFrom(classeMc("net.minecraft.world.entity.monster.Zombie")));
}
// --- FP2 : le propriétaire ne peut rien faire exploser chez lui ---
@Test
void FAUX_POSITIF_FP2_explosionsAnnuleesMemeLanceesParLeProprietaire() throws IOException {
// onExplosion retire tout bloc d'un chunk claim, sans regarder qui a allumé la TNT.
String s = source("ProtectionEvents.java");
assertTrue(s.contains("event.getAffectedBlocks().removeIf(pos -> r.ownerOf(ClaimsData.key(level, pos)) != null);"));
}
// --- Réfutés (pas de faille) ---
@Test
void honnete_amiUnilateral_lAmiDeAnAPasAccesAuxClaimsDeB() {
ClaimRegistry r = new ClaimRegistry();
UUID a = UUID.randomUUID(), b = UUID.randomUUID(), c = UUID.randomUUID();
ChunkKey ka = new ChunkKey(OW, 0, 0), kb = new ChunkKey(OW, 1, 0);
r.claim(a, ka, 25);
r.claim(b, kb, 25);
r.addFriend(a, b); // B est ami de A
r.addFriend(b, c); // C est ami de B
assertTrue(r.canAccess(b, ka, false));
assertFalse(r.canAccess(a, kb, false), "l'amitié n'est pas réciproque");
assertFalse(r.canAccess(c, ka, false), "l'amitié n'est pas transitive");
}
@Test
void honnete_claimUneDimensionNeProtegePasLAutre() {
ClaimRegistry r = new ClaimRegistry();
UUID a = UUID.randomUUID(), b = UUID.randomUUID();
r.claim(a, new ChunkKey(OW, 0, 0), 25);
assertTrue(r.canAccess(b, new ChunkKey("minecraft:the_nether", 0, 0), false));
assertFalse(r.canAccess(b, new ChunkKey(OW, 0, 0), false));
}
@Test
void honnete_coordonneesNegativesBienRangeesDansLeChunk() {
// -1 doit être dans le chunk -1 (et non 0) : sinon un claim fuirait d'un bloc.
ChunkKey k = ChunkKey.ofBlock(OW, -1, -16);
assertEquals(-1, k.x());
assertEquals(-1, k.z());
assertEquals(0, ChunkKey.ofBlock(OW, 15, 0).x());
assertEquals(1, ChunkKey.ofBlock(OW, 16, 0).x());
}
@Test
void honnete_limiteDeClaimsNonContournableParUnclaimReclaim() {
ClaimRegistry r = new ClaimRegistry();
UUID a = UUID.randomUUID();
for (int i = 0; i < 3; i++) assertEquals(ClaimRegistry.ClaimResult.OK, r.claim(a, new ChunkKey(OW, i, 0), 3));
assertEquals(ClaimRegistry.ClaimResult.LIMIT_REACHED, r.claim(a, new ChunkKey(OW, 9, 0), 3));
r.unclaim(a, new ChunkKey(OW, 0, 0));
r.unclaim(a, new ChunkKey(OW, 0, 0)); // double unclaim : le compteur ne doit pas descendre deux fois
assertEquals(2, r.countOf(a));
assertEquals(ClaimRegistry.ClaimResult.OK, r.claim(a, new ChunkKey(OW, 9, 0), 3));
assertEquals(ClaimRegistry.ClaimResult.LIMIT_REACHED, r.claim(a, new ChunkKey(OW, 10, 0), 3));
}
@Test
void honnete_unInconnuNePeutPasUnclaimNiVolerUnChunk() {
ClaimRegistry r = new ClaimRegistry();
UUID a = UUID.randomUUID(), b = UUID.randomUUID();
ChunkKey k = new ChunkKey(OW, 3, 3);
r.claim(a, k, 25);
assertEquals(ClaimRegistry.UnclaimResult.NOT_OWNER, r.unclaim(b, k));
assertEquals(ClaimRegistry.ClaimResult.CLAIMED_BY_OTHER, r.claim(b, k, 25));
assertEquals(a, r.ownerOf(k));
}
}