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