GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8 C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer (fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
6e208dccd2
révision
d90e40c8b9
1 fichier modifié
+336
@@ -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<String> appels(ClassNode classe, String methode) {
|
||||
Set<String> sortie = new HashSet<>();
|
||||
Set<String> vues = new HashSet<>();
|
||||
parcourir(classe, methode, sortie, vues);
|
||||
return sortie;
|
||||
}
|
||||
|
||||
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> 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<String> 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<String> 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<Class<?>> 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> T defaut(String champ) throws Exception {
|
||||
return ((ModConfigSpec.ConfigValue<T>) 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur