diff --git a/src/test/java/com/gastinelgarde/CablageMinecraftTest.java b/src/test/java/com/gastinelgarde/CablageMinecraftTest.java new file mode 100644 index 0000000..25db76c --- /dev/null +++ b/src/test/java/com/gastinelgarde/CablageMinecraftTest.java @@ -0,0 +1,336 @@ +package com.gastinelgarde; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.gastinelgarde.core.GardeConfig; +import java.io.InputStream; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.HashSet; +import java.util.Set; +import net.neoforged.neoforge.common.ModConfigSpec; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Test; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.ClassNode; +import org.objectweb.asm.tree.InvokeDynamicInsnNode; +import org.objectweb.asm.tree.MethodInsnNode; +import org.objectweb.asm.tree.MethodNode; + +/** + * Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements + * NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15, + * C18) du fichier toml jusqu'à la configuration du moteur. + */ +class CablageMinecraftTest { + + // --- Bytecode --- + + private static ClassNode lire(Class c) throws Exception { + try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) { + assertNotNull(in, c.getName()); + ClassNode n = new ClassNode(); + new ClassReader(in).accept(n, 0); + return n; + } + } + + /** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */ + private static Set appels(ClassNode classe, String methode) { + Set sortie = new HashSet<>(); + Set vues = new HashSet<>(); + parcourir(classe, methode, sortie, vues); + return sortie; + } + + private static void parcourir(ClassNode classe, String methode, Set sortie, Set vues) { + if (!vues.add(methode)) return; + boolean trouvee = false; + for (MethodNode m : classe.methods) { + if (!m.name.equals(methode)) continue; + trouvee = true; + for (AbstractInsnNode i : m.instructions) { + if (i instanceof MethodInsnNode mi) { + sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name); + } else if (i instanceof InvokeDynamicInsnNode d) { + for (Object a : d.bsmArgs) { + if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) { + parcourir(classe, h.getName(), sortie, vues); + } else if (a instanceof org.objectweb.asm.Handle h) { + sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName()); + } + } + } + } + } + assertTrue(trouvee, methode); + } + + @Test + void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception { + ClassNode garde = lire(Garde.class); + ClassNode events = lire(GardeEvents.class); + assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse")); + assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement")); + assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse")); + assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement")); + assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse")); + assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque")); + assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée"); + assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"), + "la marque survit à la déconnexion (C6)"); + assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction")); + Set sanction = appels(lire(Cablage.class), "appliquerSanction"); + assertTrue(sanction.contains("Moteur.expulser")); + assertTrue(sanction.contains("Moteur.apresSetback")); + assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")), + "jamais de bannissement"); + } + + /** + * FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la + * différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion + * (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops, + * stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique + * (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule, + * {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;} + * (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo. + */ + @Test + void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception { + ClassNode garde = lire(Garde.class); + Set a = appels(garde, "apresVehicule"); + assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur"); + assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_"); + assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse")); + } + + // --- Événements NeoForge abonnés --- + + @Test + void evenementsAbonnes() { + Set> ev = new HashSet<>(); + for (Method m : GardeEvents.class.getDeclaredMethods()) { + if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) { + assertEquals(1, m.getParameterCount(), m.getName()); + assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName()); + ev.add(m.getParameterTypes()[0]); + } + } + for (Class c : new Class[] { + net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class, + net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class, + net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class, + net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class, + net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class, + net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class, + net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class, + net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class, + net.neoforged.neoforge.event.server.ServerStartingEvent.class, + net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) { + assertTrue(ev.contains(c), c.getName()); + } + assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom( + net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé"); + } + + @Test + void lesFauxJoueursNeSontJamaisControles() { + // GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer. + assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom( + net.neoforged.neoforge.common.util.FakePlayer.class)); + } + + // --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) --- + + @Test + void C18_seulsLesMinecartsContenantsSontGardesImmobiles() { + Class container = net.minecraft.world.Container.class; + assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class)); + assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class)); + assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class)); + assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class)); + assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class)); + assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class)); + assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class)); + } + + @Test + void F20_vehiculesControles() { + Class bateau = net.minecraft.world.entity.vehicle.Boat.class; + Class monture = net.minecraft.world.entity.LivingEntity.class; + assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau"); + assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class)); + assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class)); + Class minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class; + assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart), + "minecart : non contrôlé (type AUTRE), la position de retour suit le joueur"); + } + + // --- Options : du fichier toml au moteur --- + + private static Object valeur(String champ) throws Exception { + Field f = GardeSpec.class.getDeclaredField(champ); + f.setAccessible(true); + return f.get(null); + } + + @SuppressWarnings("unchecked") + private static T defaut(String champ) throws Exception { + return ((ModConfigSpec.ConfigValue) valeur(champ)).getDefault(); + } + + @Test + void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception { + GardeConfig c = new GardeConfig(); + assertEquals(false, defaut("ELYTRES_STRICTE")); + assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE")); + assertEquals(2, (int) defaut("ELYTRES_AIR_MIN")); + assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN")); + assertEquals(false, defaut("COMBAT_VEHICULE")); + assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE")); + assertEquals(false, defaut("VOL_FENETRE_GLISSANTE")); + assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE")); + assertEquals(false, defaut("VITESSE_MOYENNE")); + assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE")); + assertEquals(0, (int) defaut("TIMER_SOLDE_MAX")); + assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX")); + assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE")); + assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT")); + assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement); + assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut"); + } + + @Test + void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception { + // Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet. + Path toml = null; + for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) { + Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml"); + if (Files.exists(f)) toml = f; + } + Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath()); + String t = Files.readString(toml, StandardCharsets.UTF_8); + for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante", + "vitesseMoyenne", "empilementSeulementEnMouvement"}) { + assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle); + } + assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax"); + } + + /** + * GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire + * (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge. + */ + @Test + void appliquerRecopieLesOptionsDuFichier() throws Exception { + Object charge = chargerEnMemoire(); + Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici"); + try { + assertTrue(GardeSpec.SPEC.isLoaded()); + GardeConfig vide = new GardeConfig(); + GardeSpec.appliquer(vide); + assertFalse(vide.elytresExemptionStricte); + assertFalse(vide.combatMesureEnVehicule); + assertFalse(vide.volFenetreGlissante); + assertFalse(vide.vitesseMoyenne); + assertEquals(0, vide.timerSoldeMax); + for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) { + assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k); + } + + ((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true); + ((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5); + ((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true); + ((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true); + ((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true); + ((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20); + GardeConfig c = new GardeConfig(); + GardeSpec.appliquer(c); + assertTrue(c.elytresExemptionStricte, "C7"); + assertEquals(5, c.elytresAirMinTicks, "C7"); + assertTrue(c.combatMesureEnVehicule, "C8"); + assertTrue(c.volFenetreGlissante, "C10"); + assertTrue(c.vitesseMoyenne, "C15"); + assertEquals(20, c.timerSoldeMax, "C15"); + } finally { + dechargerEnMemoire(); + } + assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé"); + } + + /** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */ + private static Object chargerEnMemoire() { + try { + Method accept = null; + for (Method m : ModConfigSpec.class.getMethods()) { + if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m; + } + if (accept == null) return null; + Class type = accept.getParameterTypes()[0]; + com.electronwill.nightconfig.core.CommentedConfig cc = + com.electronwill.nightconfig.core.CommentedConfig.inMemory(); + // Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder. + for (Method m : ModConfigSpec.class.getMethods()) { + if (m.getName().equals("correct") && m.getParameterCount() == 1 + && m.getParameterTypes()[0].isInstance(cc)) { + m.invoke(GardeSpec.SPEC, cc); + break; + } + } + Object config = null; + if (type.isInstance(cc)) { + config = cc; + } else if (type.isSealed()) { + // NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig. + for (Class impl : type.getPermittedSubclasses()) { + for (java.lang.reflect.Constructor k : impl.getDeclaredConstructors()) { + Class[] p = k.getParameterTypes(); + if (p.length == 0 || !p[0].isInstance(cc)) continue; + Object[] args = new Object[p.length]; + args[0] = cc; + k.setAccessible(true); + config = k.newInstance(args); + break; + } + if (config != null) break; + } + } else if (type.isInterface()) { + config = Proxy.newProxyInstance(type.getClassLoader(), new Class[] {type}, (o, m, a) -> switch (m.getName()) { + case "config" -> cc; + case "hashCode" -> System.identityHashCode(o); + case "equals" -> o == a[0]; + case "toString" -> "config-en-memoire"; + default -> null; + }); + } + if (config == null) return null; + accept.invoke(GardeSpec.SPEC, config); + return GardeSpec.SPEC.isLoaded() ? config : null; + } catch (ReflectiveOperationException | RuntimeException | LinkageError e) { + System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e); + dechargerEnMemoire(); + return null; + } + } + + private static void dechargerEnMemoire() { + try { + for (Method m : ModConfigSpec.class.getMethods()) { + if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) { + m.invoke(GardeSpec.SPEC, new Object[] {null}); + } + } + } catch (ReflectiveOperationException | RuntimeException e) { + System.out.println("[CablageMinecraftTest] déchargement : " + e); + } + } +}