diff --git a/src/main/java/fr/hashimiste/core/gui/JFrameTemplate.java b/src/main/java/fr/hashimiste/core/gui/JFrameTemplate.java index d87922b..efb4d49 100644 --- a/src/main/java/fr/hashimiste/core/gui/JFrameTemplate.java +++ b/src/main/java/fr/hashimiste/core/gui/JFrameTemplate.java @@ -5,6 +5,9 @@ import fr.hashimiste.impl.gui.dev.DebugFrame; import fr.hashimiste.impl.gui.theme.DebugTheme; import fr.hashimiste.impl.gui.theme.DefaultTheme; +import fr.hashimiste.impl.gui.theme.CandyTheme; +import fr.hashimiste.impl.gui.theme.DarkTheme; + import javax.swing.*; import java.awt.*; @@ -182,6 +185,10 @@ protected void rechargerTheme() { this.theme = DefaultTheme.INSTANCE; if (properties.getProperty("theme").equals("debug")) { this.theme = DebugTheme.INSTANCE; + }else if(properties.getProperty("theme").equals("candy")){ + this.theme = CandyTheme.INSTANCE; + }else if(properties.getProperty("theme").equals("dark")){ + this.theme = DarkTheme.INSTANCE; } appliquerTheme(composantStylise.toArray(new JComponent[0])); } diff --git a/src/main/java/fr/hashimiste/impl/gui/menu/Parametre.java b/src/main/java/fr/hashimiste/impl/gui/menu/Parametre.java index a878aa3..fcacc49 100644 --- a/src/main/java/fr/hashimiste/impl/gui/menu/Parametre.java +++ b/src/main/java/fr/hashimiste/impl/gui/menu/Parametre.java @@ -18,7 +18,7 @@ public class Parametre extends JFrameTemplateProfil { private final JButton butMenu = creerBoutton("Menu", fenetreParente); private final JLabel labTheme = new JLabel("Thème : "); - private final JComboBox themes = new JComboBox<>(new String[]{"default", "debug"}); + private final JComboBox themes = new JComboBox<>(new String[]{"default", "debug", "candy", "dark"}); private final JButton butSave = creerBoutton("Sauvegarder", this::sauvegarder); /** diff --git a/src/main/java/fr/hashimiste/impl/gui/theme/CandyTheme.java b/src/main/java/fr/hashimiste/impl/gui/theme/CandyTheme.java new file mode 100644 index 0000000..597bf73 --- /dev/null +++ b/src/main/java/fr/hashimiste/impl/gui/theme/CandyTheme.java @@ -0,0 +1,89 @@ +package fr.hashimiste.impl.gui.theme; + +import fr.hashimiste.core.gui.Theme; + +import java.awt.*; + +/** + * La classe DefaultTheme implémente l'interface Theme. + * Elle définit un thème par défaut avec des couleurs spécifiques pour les différents éléments de l'interface utilisateur. + */ +public class CandyTheme implements Theme { + /** + * L'instance unique de la classe DefaultTheme. + */ + public static final Theme INSTANCE = new CandyTheme(); + + /** + * La couleur des boutons dans le thème par défaut. + */ + private static final Color BOUTON = new Color(255, 10, 84); + + /** + * La couleur du texte des boutons dans le thème par défaut. + */ + private static final Color TEXTE_BOUTON; + + static { + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.contains("mac")) { + // Mac + TEXTE_BOUTON = Color.BLACK; + } else { + // Autres systèmes (Linux, etc.) + TEXTE_BOUTON = new Color(251, 250, 242); // Couleur par défaut + } + } + + /** + * La couleur des boutons désactivés dans le thème par défaut. + */ + private static final Color BOUTON_DESACTIVE = new Color(255, 92, 138); + + /** + * La couleur de fond dans le thème par défaut. + */ + private static final Color FOND = new Color(255, 153, 172); + + /** + * La couleur transparente dans le thème par défaut. + */ + private static final Color TRANSPARENT = new Color(0, 0, 0, 0); + + /** + * Le constructeur privé de la classe DefaultTheme. + * Il est privé pour empêcher l'instanciation directe de cette classe. + */ + private CandyTheme() { + } + + @Override + public Color getButtonColor() { + return BOUTON; + } + + @Override + public Color getButtonTextColor() { + return TEXTE_BOUTON; + } + + @Override + public Color getDisabledButtonColor() { + return BOUTON_DESACTIVE; + } + + @Override + public Color getBackgroundColor() { + return FOND; + } + + @Override + public Color getTransparentColor() { + return TRANSPARENT; + } + + @Override + public Color getTextColor() { + return Color.BLACK; + } +} diff --git a/src/main/java/fr/hashimiste/impl/gui/theme/DarkTheme.java b/src/main/java/fr/hashimiste/impl/gui/theme/DarkTheme.java new file mode 100644 index 0000000..5abf089 --- /dev/null +++ b/src/main/java/fr/hashimiste/impl/gui/theme/DarkTheme.java @@ -0,0 +1,89 @@ +package fr.hashimiste.impl.gui.theme; + +import fr.hashimiste.core.gui.Theme; + +import java.awt.*; + +/** + * La classe DefaultTheme implémente l'interface Theme. + * Elle définit un thème par défaut avec des couleurs spécifiques pour les différents éléments de l'interface utilisateur. + */ +public class DarkTheme implements Theme { + /** + * L'instance unique de la classe DefaultTheme. + */ + public static final Theme INSTANCE = new DarkTheme(); + + /** + * La couleur des boutons dans le thème par défaut. + */ + private static final Color BOUTON = new Color(58, 1, 92); + + /** + * La couleur du texte des boutons dans le thème par défaut. + */ + private static final Color TEXTE_BOUTON; + + static { + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.contains("mac")) { + // Mac + TEXTE_BOUTON = Color.BLACK; + } else { + // Autres systèmes (Linux, etc.) + TEXTE_BOUTON = new Color(251, 250, 242); // Couleur par défaut + } + } + + /** + * La couleur des boutons désactivés dans le thème par défaut. + */ + private static final Color BOUTON_DESACTIVE = new Color(79, 1, 71); + + /** + * La couleur de fond dans le thème par défaut. + */ + private static final Color FOND = new Color(110, 30, 82); + + /** + * La couleur transparente dans le thème par défaut. + */ + private static final Color TRANSPARENT = new Color(0, 0, 0, 0); + + /** + * Le constructeur privé de la classe DefaultTheme. + * Il est privé pour empêcher l'instanciation directe de cette classe. + */ + private DarkTheme() { + } + + @Override + public Color getButtonColor() { + return BOUTON; + } + + @Override + public Color getButtonTextColor() { + return TEXTE_BOUTON; + } + + @Override + public Color getDisabledButtonColor() { + return BOUTON_DESACTIVE; + } + + @Override + public Color getBackgroundColor() { + return FOND; + } + + @Override + public Color getTransparentColor() { + return TRANSPARENT; + } + + @Override + public Color getTextColor() { + return Color.WHITE; + } +} diff --git a/src/main/java/fr/hashimiste/impl/gui/theme/DebugTheme.java b/src/main/java/fr/hashimiste/impl/gui/theme/DebugTheme.java index 9ac47d3..365203c 100644 --- a/src/main/java/fr/hashimiste/impl/gui/theme/DebugTheme.java +++ b/src/main/java/fr/hashimiste/impl/gui/theme/DebugTheme.java @@ -23,7 +23,18 @@ public class DebugTheme implements Theme { /** * La couleur du texte des boutons dans le thème de débogage. */ - private static final Color TEXTE_BOUTON = new Color(251, 250, 242); + private static final Color TEXTE_BOUTON; + + static { + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.contains("mac")) { + // Mac + TEXTE_BOUTON = Color.BLACK; // Pour Mac + } else { + // Autres systèmes (Linux, etc.) + TEXTE_BOUTON = new Color(251, 250, 242); // Couleur par défaut + } + } /** * La couleur des boutons désactivés dans le thème de débogage. diff --git a/src/main/java/fr/hashimiste/impl/gui/theme/DefaultTheme.java b/src/main/java/fr/hashimiste/impl/gui/theme/DefaultTheme.java index 9fc83a9..afbc78f 100644 --- a/src/main/java/fr/hashimiste/impl/gui/theme/DefaultTheme.java +++ b/src/main/java/fr/hashimiste/impl/gui/theme/DefaultTheme.java @@ -21,8 +21,20 @@ public class DefaultTheme implements Theme { /** * La couleur du texte des boutons dans le thème par défaut. + * Si windows, alors 251, 250, 242, sur mac, 0, 0, 0 */ - private static final Color TEXTE_BOUTON = new Color(251, 250, 242); + private static final Color TEXTE_BOUTON; + + static { + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.contains("mac")) { + // Mac + TEXTE_BOUTON = Color.BLACK; + } else { + // Autres systèmes (Linux, etc.) + TEXTE_BOUTON = new Color(251, 250, 242); // Couleur par défaut + } + } /** * La couleur des boutons désactivés dans le thème par défaut. diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/AventureTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/AventureTest.java new file mode 100644 index 0000000..ab0d0d0 --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/AventureTest.java @@ -0,0 +1,68 @@ +package fr.hashimiste.impl.gui.menu; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.awt.*; +import java.io.IOException; +import java.util.*; + +class AventureTest extends TestMenu{ + private Aventure aventure; + + /** + * Renvoie le conteneur à tester + * @return le conteneur à tester + */ + @Override + protected Container getTestContainer() { + return aventure; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + aventure = (Aventure) testMenuInitialisations(aventure, "Aventure"); + + System.out.println("L'initialisation du menu réussi"); + } + + /** + * Teste le menu Paramètre + */ + @Test + void testMenuParametre(){ + testerMenu(aventure, "Hashimiste", new Dimension(800, 600)); + + testThemeMenu(aventure, "default"); + testThemeMenu(aventure, "candy"); + + System.out.println("Le test du changement de thème réussi"); + } + + /** + * Teste tous les boutons du menu + */ + @Test + void testTousLesBoutons() { + // Création d'une carte pour mapper le nom du bouton à son état attendu (true pour actif, false pour inactif) + Map boutonsEtEtats = new HashMap<>(); + boutonsEtEtats.put("Menu", true); + boutonsEtEtats.put("Niveau 1", false); + boutonsEtEtats.put("Niveau 2", false); + boutonsEtEtats.put("Niveau 3", false); + boutonsEtEtats.put("Niveau 4", false); + boutonsEtEtats.put("Niveau 5", false); + boutonsEtEtats.put("Niveau 6", false); + boutonsEtEtats.put("Niveau 7", false); + boutonsEtEtats.put("Niveau 8", false); + boutonsEtEtats.put("Niveau 9", false); + boutonsEtEtats.put("Niveau 10", false); + + // Itération sur chaque entrée de la carte pour vérifier chaque bouton + boutonsEtEtats.forEach(this::verifierEtatBouton); + } +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/MenuTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/MenuTest.java new file mode 100644 index 0000000..9fe16c0 --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/MenuTest.java @@ -0,0 +1,114 @@ +package fr.hashimiste.impl.gui.menu; + +import static org.junit.jupiter.api.Assertions.*; + +import fr.hashimiste.core.data.Filter; +import fr.hashimiste.core.data.Join; +import fr.hashimiste.core.data.Stockage; +import fr.hashimiste.impl.joueur.ProfilImpl; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import javax.swing.*; +import java.awt.*; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.*; +import java.util.List; + +import fr.hashimiste.core.joueur.Profil; +import fr.hashimiste.core.gui.JFrameTemplate; + +class MenuTest extends TestMenu { + + private Menu menu; + + /** + * Renvoie le conteneur à tester + * @return le conteneur à tester + */ + @Override + protected Container getTestContainer() { + return menu; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + ProfilImpl test = new ProfilImpl("test"); + Path tempFile = Files.createTempFile("", ""); + tempFile.toFile().deleteOnExit(); + Properties properties = new Properties(); + properties.setProperty("theme", "default"); + properties.store(Files.newOutputStream(tempFile), "Hashimiste properties"); + Stockage stockage = new Stockage() { + @Override + public List charger(Class clazz, String extra) { + if (clazz == Profil.class) { + return (List) Collections.singletonList(test); + } + return Collections.emptyList(); + } + + @Override + public List charger(Class clazz, List jointures, Filter filtre) { + return this.charger(clazz, (String) null); + } + + @Override + public void sauvegarder(List list) { + } + + @Override + public void supprimer(Class clazz, Filter filtre) { + } + }; + menu = new Menu(new JFrameTemplate(null, tempFile.toFile(), stockage, new Dimension(0, 0)) { + @Override + public void changerFenetre(JFrame window) { + throw new UnsupportedOperationException("Not supported yet."); + } + }, test); + + assertEquals(test, menu.getProfil(), "Le profil devrait être le profil passé en paramètre"); + + System.out.println("L'initialisation du menu réussi"); + } + + /** + * Teste le menu principal + */ + @Test + void testMenu() { + + testerMenu(menu, "Hashimiste", new Dimension(800, 600)); + + testThemeMenu(menu, "default"); + testThemeMenu(menu, "candy"); + + System.out.println("Le test du menu est réussi"); + } + + /** + * Teste tous les boutons du menu + */ + @Test + void testTousLesBoutons() { + // Création d'une carte pour mapper le nom du bouton à son état attendu (true pour actif, false pour inactif) + Map boutonsEtEtats = new HashMap<>(); + boutonsEtEtats.put("Paramètre", true); + boutonsEtEtats.put("Aventure", true); + boutonsEtEtats.put("Tutoriel", false); + boutonsEtEtats.put("Mode libre", true); + boutonsEtEtats.put("Multijoueur", false); + boutonsEtEtats.put("Technique", true); + boutonsEtEtats.put("Profils", true); + + // Itération sur chaque entrée de la carte pour vérifier chaque bouton + boutonsEtEtats.forEach(this::verifierEtatBouton); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/ModeLibreTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/ModeLibreTest.java new file mode 100644 index 0000000..ab211ca --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/ModeLibreTest.java @@ -0,0 +1,59 @@ +package fr.hashimiste.impl.gui.menu; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.awt.*; +import java.io.IOException; +import java.util.*; + +class ModeLibreTest extends TestMenu{ + + private ModeLibre modeLibre; + + /** + * Renvoie le conteneur à tester + * @return le conteneur à tester + */ + @Override + protected Container getTestContainer() { + return modeLibre; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + modeLibre = (ModeLibre) testMenuInitialisations(modeLibre, "ModeLibre"); + + System.out.println("L'initialisation du menu réussi"); + } + + /** + * Teste le menu mode libre + */ + @Test + void testMenuModeLibre(){ + testerMenu(modeLibre, "Hashimiste", new Dimension(800, 600)); + + testThemeMenu(modeLibre, "default"); + testThemeMenu(modeLibre, "candy"); + + System.out.println("Le test du changement de thème réussi"); + } + + /** + * Teste tous les boutons du menu + */ + @Test + void testTousLesBoutons() { + // Création d'une carte pour mapper le nom du bouton à son état attendu (true pour actif, false pour inactif) + Map boutonsEtEtats = new HashMap<>(); + boutonsEtEtats.put("Menu", true); + + // Itération sur chaque entrée de la carte pour vérifier chaque bouton + boutonsEtEtats.forEach(this::verifierEtatBouton); + } +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/ParametreTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/ParametreTest.java new file mode 100644 index 0000000..b8f2b7d --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/ParametreTest.java @@ -0,0 +1,62 @@ +package fr.hashimiste.impl.gui.menu; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.awt.*; +import java.io.IOException; +import java.util.*; + +class ParametreTest extends TestMenu{ + + private Parametre parametre; + + /** + * Renvoie le conteneur à tester + * @return le conteneur à tester + */ + @Override + protected Container getTestContainer() { + return parametre; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + parametre = (Parametre) testMenuInitialisations(parametre, "Parametre"); + + System.out.println("L'initialisation du menu réussi"); + } + + /** + * Teste le menu Paramètre + */ + @Test + void testMenuParametre(){ + testerMenu(parametre, "Hashimiste", new Dimension(800, 600)); + + testThemeMenu(parametre, "default"); + testThemeMenu(parametre, "candy"); + + System.out.println("Le test du changement de thème réussi"); + } + + /** + * Teste tous les boutons du menu + */ + @Test + void testTousLesBoutons() { + // Création d'une carte pour mapper le nom du bouton à son état attendu (true pour actif, false pour inactif) + Map boutonsEtEtats = new HashMap<>(); + boutonsEtEtats.put("Sauvegarder", true); + boutonsEtEtats.put("Menu", true); + + // Itération sur chaque entrée de la carte pour vérifier chaque bouton + boutonsEtEtats.forEach(this::verifierEtatBouton); + } + + +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/ProfilSelectionTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/ProfilSelectionTest.java new file mode 100644 index 0000000..cd21463 --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/ProfilSelectionTest.java @@ -0,0 +1,78 @@ +package fr.hashimiste.impl.gui.menu; +import fr.hashimiste.core.data.Filter; +import fr.hashimiste.core.data.Join; +import fr.hashimiste.core.data.Stockage; +import fr.hashimiste.core.joueur.Profil; +import fr.hashimiste.impl.joueur.ProfilImpl; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.awt.*; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Collections; +import java.util.List; +import java.util.Properties; + +class ProfilSelectionTest extends TestMenu{ + private ProfilSelection profilSelection; + + @Override + protected Container getTestContainer() { + return profilSelection; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + ProfilImpl test = new ProfilImpl("test"); + Path tempFile = Files.createTempFile("", ""); + tempFile.toFile().deleteOnExit(); + Properties properties = new Properties(); + properties.setProperty("theme", "default"); + properties.store(Files.newOutputStream(tempFile), "Hashimiste properties"); + Stockage stockage = new Stockage() { + @Override + public java.util.List charger(Class clazz, String extra) { + if (clazz == Profil.class) { + return (java.util.List) Collections.singletonList(test); + } + return Collections.emptyList(); + } + + @Override + public java.util.List charger(Class clazz, java.util.List jointures, Filter filtre) { + return this.charger(clazz, (String) null); + } + + @Override + public void sauvegarder(List list) { + } + + @Override + public void supprimer(Class clazz, Filter filtre) { + } + }; + profilSelection = new ProfilSelection(tempFile.toFile(), stockage); + + System.out.println("L'initialisation du menu réussi"); + } + + + /** + * Teste le menu de selection de profil + */ + @Test + void testMenuProfilSelection(){ + testerMenu(profilSelection, "Hashimiste", new Dimension(500, 300)); + + testThemeMenu(profilSelection, "default"); + testThemeMenu(profilSelection, "candy"); + + System.out.println("Le test du changement de thème réussi"); + } +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/TechniqueTest.java b/src/test/java/fr/hashimiste/impl/gui/menu/TechniqueTest.java new file mode 100644 index 0000000..a3a2679 --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/TechniqueTest.java @@ -0,0 +1,57 @@ +package fr.hashimiste.impl.gui.menu; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.awt.*; +import java.io.IOException; +import java.util.*; + +class TechniqueTest extends TestMenu{ + private Technique technique; + + /** + * Renvoie le conteneur à tester + * @return le conteneur à tester + */ + @Override + protected Container getTestContainer() { + return technique; + } + + /** + * Teste l'initialisation du menu + * @throws IOException si une erreur d'entrée/sortie survient + */ + @BeforeEach + void testMenuInitialisation() throws IOException { + technique = (Technique) testMenuInitialisations(technique, "Technique"); + + System.out.println("L'initialisation du menu réussi"); + } + + /** + * Teste le menu technique + */ + @Test + void testMenuParametre(){ + testerMenu(technique, "Hashimiste", new Dimension(800, 600)); + + testThemeMenu(technique, "default"); + testThemeMenu(technique, "candy"); + + System.out.println("Le test du changement de thème réussi"); + } + + /** + * Teste tous les boutons du menu + */ + @Test + void testTousLesBoutons() { + // Création d'une carte pour mapper le nom du bouton à son état attendu (true pour actif, false pour inactif) + Map boutonsEtEtats = new HashMap<>(); + boutonsEtEtats.put("Menu", true); + + boutonsEtEtats.forEach(this::verifierEtatBouton); + } +} \ No newline at end of file diff --git a/src/test/java/fr/hashimiste/impl/gui/menu/TestMenu.java b/src/test/java/fr/hashimiste/impl/gui/menu/TestMenu.java new file mode 100644 index 0000000..5afb699 --- /dev/null +++ b/src/test/java/fr/hashimiste/impl/gui/menu/TestMenu.java @@ -0,0 +1,185 @@ +package fr.hashimiste.impl.gui.menu; + +import fr.hashimiste.core.data.Filter; +import fr.hashimiste.core.data.Join; +import fr.hashimiste.core.data.Stockage; +import fr.hashimiste.core.gui.JFrameTemplateProfil; +import fr.hashimiste.core.joueur.Profil; +import fr.hashimiste.impl.gui.theme.DefaultTheme; +import fr.hashimiste.impl.joueur.ProfilImpl; +import org.opentest4j.AssertionFailedError; + +import javax.swing.*; + +import java.awt.*; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.Properties; +import java.util.function.Predicate; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import fr.hashimiste.core.gui.JFrameTemplate; + +public abstract class TestMenu { + + protected abstract Container getTestContainer(); + + /** + * Teste le menu + * + * @param menu le menu à tester + * @param titreAttendu le titre attendu + * @param dimensionAttendue la dimension attendue + */ + protected void testerMenu(JFrame menu, String titreAttendu, Dimension dimensionAttendue) { + // Test si les composants ne sont pas null + assertNotNull(menu, "Le menu ne devrait pas être null"); + + // Test si le menu est activé + assertTrue(menu.isEnabled(), "Le menu devrait être activé"); + + // Test si la dimension par défaut est appliquée + assertEquals(dimensionAttendue, menu.getSize(), "La dimension par défaut devrait être " + dimensionAttendue); + + // Test si le titre est appliqué + assertEquals(titreAttendu, menu.getTitle(), "Le titre devrait être '" + titreAttendu + "'"); + + System.out.println("Le test des composants du menu réussi"); + } + + /** + * Teste le thème du menu + * + * @param menu le menu à tester + * @param themeAttendu le thème attendu + */ + protected void testThemeMenu(JFrameTemplate menu, String themeAttendu) { + + menu.getProperties().setProperty("theme", themeAttendu); + assertEquals(themeAttendu, menu.getProperties().getProperty("theme"), "Le thème devrait être " + themeAttendu); + + System.out.println("Le test du thème " + themeAttendu + " du menu réussi"); + } + + /** + * Teste l'état des boutons + * + * @param nomBouton le nom du bouton + * @param attenduActif l'état attendu du bouton + */ + protected void verifierEtatBouton(String nomBouton, boolean attenduActif) { + JButton bouton = getComponentByName(JButton.class, getTestContainer(), c -> nomBouton.equals(c.getText())) + .orElseThrow(() -> new AssertionFailedError("Le bouton " + nomBouton + " n'a pas été trouvé")); + assertNotNull(bouton, "Le bouton " + nomBouton + " ne devrait pas être null"); + assertEquals(attenduActif, bouton.isEnabled(), "L'état activé du bouton " + nomBouton + " est incorrect"); + assertEquals(nomBouton, bouton.getText(), "Le texte du bouton ne correspond pas à " + nomBouton); + + DefaultTheme theme = (DefaultTheme) DefaultTheme.INSTANCE; + assertEquals(attenduActif ? theme.getButtonColor() : theme.getDisabledButtonColor(), bouton.getBackground(), "La couleur du bouton devrait correspondre au thème"); + assertEquals(theme.getButtonTextColor(), bouton.getForeground(), "La couleur du texte du bouton devrait correspondre au thème"); + + System.out.println("Le test du bouton " + nomBouton + " réussi"); + } + + /** + * Initialise le menu et vérifie que le profil passé en paramètre est bien le profil du menu + * + * @param menu le menu à initialiser + * @param nomMenu le nom du menu + * @return le menu initialisé + */ + protected JFrameTemplateProfil testMenuInitialisations(JFrameTemplateProfil menu, String nomMenu) throws IOException { + ProfilImpl test = new ProfilImpl("test"); + Path tempFile = Files.createTempFile("", ""); + tempFile.toFile().deleteOnExit(); + Properties properties = new Properties(); + properties.setProperty("theme", "default"); + properties.store(Files.newOutputStream(tempFile), "Hashimiste properties"); + Stockage stockage = new Stockage() { + @Override + public java.util.List charger(Class clazz, String extra) { + if (clazz == Profil.class) { + return (java.util.List) Collections.singletonList(test); + } + return Collections.emptyList(); + } + + @Override + public java.util.List charger(Class clazz, java.util.List jointures, Filter filtre) { + return this.charger(clazz, (String) null); + } + + @Override + public void sauvegarder(List list) { + } + + @Override + public void supprimer(Class clazz, Filter filtre) { + } + }; + JFrameTemplate frame = new ProfilSelection(tempFile.toFile(), stockage); + frame = new Menu(frame, test); + switch (nomMenu) { + case "Aventure": + menu = new Aventure((JFrameTemplateProfil) frame); + break; + case "ModeLibre": + menu = new ModeLibre((JFrameTemplateProfil) frame); + break; + case "Parametre": + menu = new Parametre((JFrameTemplateProfil) frame); + break; + case "Technique": + menu = new Technique((JFrameTemplateProfil) frame); + break; + default: + break; + + + } + + assertEquals(test, menu.getProfil(), "Le profil devrait être le profil passé en paramètre"); + + System.out.println("L'initialisation du menu réussi"); + + return menu; + } + + /** + * Récupère un composant par son nom + * + * @param clazz la classe du composant + * @param parent le conteneur parent + * @param filter le filtre + * @param le type du composant + * @return le composant + */ + protected Optional getComponentByName(Class clazz, Container parent, Predicate filter) { + Optional t = Arrays.stream(parent.getComponents()) + .filter(clazz::isInstance) + .map(clazz::cast) + .filter(filter) + .findFirst(); + if (t.isPresent()) { + return t; + } + for (Component c : parent.getComponents()) { + if (c instanceof Container) { + t = getComponentByName(clazz, (Container) c, filter); + if (t.isPresent()) { + return t; + } + } + } + return Optional.empty(); + } +} \ No newline at end of file