20 Septembre

DEV2.1/TP7:Evenements/Attente.java

@@ -1,6 +1,7 @@
 import java.awt.*;
 import javax.swing.*;
 import java.awt.event.*;
+import java.lang.*
 
 public class Attente extends JPanel implements WindowListener{
 

DEV2.1/TP8/MonInt.java

@@ -0,0 +1,98 @@
+// notez le s apres Object. Permet entre autre de stipuler qu'un objet o n'est pas null avec la methode Objects.requireNonNull(o, "message d'erreur detaille");
+import java.util.Objects;
+/*
+ * Sorte de Int du pauvre a laquelle on ajoute un nom sous forme textuelle.
+ * 
+ * Classe donnee a titre d'exemple pour illustrer les ingredients techniques de la prog defensive.
+ * et les assertions java
+ */
+public class MonInt {
+    // un entier
+    private int valeur ;
+    // son nom sous forme textuelle
+    private String nom ;
+    
+    public MonInt(int n, String s){
+        this.valeur = n;
+        this.nom = s;
+    }
+    /**
+     * division du pauvre.
+     *
+     *
+     * @param c le diviseur par lequel on souhaite diviser this
+     */
+    public void divise (MonInt c){
+        Objects.requireNonNull(c, "la classe denominateur ne peut pas etre null");
+        int avant = this.valeur;
+        
+        this.valeur = this.valeur / c.getValeur();
+        this.nom = "(" + this.nom + " divise par " + c.getNom() +")";
+        assert(this.valeur*c.getValeur() == avant); // NB. un assert qui ne marche pas tout le temps.
+    }
+    /**
+     * Un getter superstitieux.
+     * retourne une exception si la valeur vaut 13.
+     */
+    public int getValeur(){
+        if (valeur == 13) throw new IllegalStateException("Comme disait Sacha Guitry, je ne suis pas superstitieux mais on ne sait jamais.");
+        return valeur;
+    }
+    public String getNom(){
+        return nom;
+    }
+    /**
+    * @return String representant l'entier.
+    */ 
+    public String toString(){
+        return this.getValeur() + " " + this.getNom();
+    }
+    /**
+     * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+     * C'est plutot mieux que de mettre des print dans chaque methode car vous etes plus sur de la stabilite de vos tests 
+     * (vous pouvez rejouer les tests plus tard).
+     *
+     * Idealement on utilise un outil dedie comme JUnit qui favorise au maximum cette automatisation.
+     *
+     * @param args pas de parametre en ligne de commande prevu.
+     */
+    public static void main(String[] args) {
+        MonInt c3 = new MonInt(3,"trois");
+        MonInt c4 = new MonInt(4,"quatre");
+        MonInt c9 = new MonInt(9,"neuf");
+        MonInt c13 = new MonInt(13,"treize");
+        System.out.println(c3.toString());
+        System.out.println(c4.toString());
+        System.out.println(c9.toString());
+        c9.divise(c3);
+        // 3
+        System.out.println(c9.toString());
+        c3.divise(c4);
+        // 0
+        System.out.println(c3.toString());
+        // tester des exceptions pas pratique
+        // Si on veut tester plusieurs exceptions
+        // il faut attraper et verifier que c'est le bon type d'exception.
+        // ici manuellement en regardant le message.
+        try {
+            System.out.println(c13.toString()); // toucher au nbre 13 avec getValeur()
+        }
+        catch(Exception e){
+            System.out.println(e);
+        }
+        
+        try{
+            c9.divise(c3); //division par 0
+            }
+        catch(Exception e){
+            System.out.println(e);
+        }
+        try{
+            c9.divise(null); //division par null
+        }
+        catch(Exception e){
+            System.out.println(e);
+        }
+        
+    }
+}

DEV2.1/TP8/v0/Carte.java

@@ -0,0 +1,150 @@
+import java.util.Objects;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+/**
+ * Classe représentant une carte de Memory
+ */
+public class Carte {
+    
+    /**
+     * Permet de savoir combien on a de cartes en tout.
+     * Pas vraiment clair qu'on veuille s'en servir ici. 
+     * C'est purement pour des raisons pédagogiques de rappel de ce que veut dire un attribut de classe.
+     * 
+     * Je ne rentre pas dans les détails de la destruction d'objets.
+     * Il faut lire la doc à propos de Objects.finalize()
+    */
+    static int nbreCarte;
+
+    /**
+     * False ssi caché
+     */
+    private boolean visible; 
+    
+    /**
+     * pour pouvoir apparier des cartes.
+     */
+    private int valeur;    
+
+    /** Constructeur de carte.
+    */
+    public Carte(int valeur){
+        this.nbreCarte ++;
+        this.visible=false; // caché par défaut
+        this.valeur=valeur;
+    }
+
+    // NB. Moralement, les cartes ne devraient pas être cachées.
+    // dans cette version on ne fait rien mais on voudrait idéalement que ce ne soit pas possible
+    /**
+     *  Prédicat permettant de tester le fait que deux cartes ont la même valeur
+     * @param Carte la carte à comparer à this. 
+     * @return true si elles ont la même valeur. 
+     * @throws NullPointerException si la carte passée en paramètre ou this est null.
+     * @throws IllegalArgumentException si l'argument n'est pas visible
+     * @throws IllegalStateExeption si this n'est pas visible
+     */
+    public boolean egale(Carte c){
+        Objects.requireNonNull(c, "la carte à tester passée en paramètre ne peut pas être null");
+        Objects.requireNonNull(this, "la carte qu'on veut comparer (this) ne peut pas être null");
+        if(!c.visible){
+                            throw new IllegalArgumentException("carte en argument non visible");
+        } if (!this.visible){
+            throw new IllegalArgumentException ("carte courante non visible");
+        } 
+        return c.valeur == this.valeur;
+    }
+
+    public boolean getVisible(){
+        return visible;
+    }
+
+    /**
+     * Méthode inversant la visibilité d'une carte.
+     */
+    public void toggleVisible(){
+        this.visible = ! this.visible;
+    }
+
+  /**
+    * @return String representant la carte (version longue)
+    * @see toString
+    */ 
+    public String toStringLong(){
+        return  this.toString() + " parmi " + this.nbreCarte;
+    }
+
+    /**
+    * @return String representant la carte.
+    */ 
+    public String toString(){
+        return "une carte " + (this.visible ? "visible" + " de valeur " + this.valeur: "cachée");
+    }
+
+    /**
+     * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+     * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests 
+     * (vous pouvez rejouer les tests plus tard).
+     *
+     * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation.
+     * @param args pas de paramètre en ligne de commande prévu.
+     */
+    public static void main(String[] args) {
+        Carte un = new Carte(1);
+        System.out.println(un.toString());
+        Carte deux = new Carte (2);
+        System.out.println(deux.toString());
+        Carte unBis = new Carte(1);
+        System.out.println(unBis.toString());
+
+        un.toggleVisible();
+        System.out.println(un.toString());
+        unBis.toggleVisible();
+        System.out.println(unBis.toString());
+        System.out.println(un.egale(unBis));
+        unBis.toggleVisible();//true
+        System.out.println(unBis.toString());
+
+        System.out.println(un.toString());
+        deux.toggleVisible();
+        System.out.println(deux.toString());
+        System.out.println(!un.egale(deux));//not false
+
+        Carte bad = null;
+        un.egale(bad);
+    }
+}
+
+

DEV2.1/TP8/v0/EnsembleCarte.java

@@ -0,0 +1,142 @@
+import java.util.LinkedHashSet;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+
+
+/**
+ * classe abstraite pour gérer les opérations sur les ensembles de carte qu'on trouve au memory
+ * 
+ */
+public abstract class EnsembleCarte {
+    /**
+     * La structure de donnée utilisée pour stocker les cartes dans la partie Collection de java.util.
+     * En gros, c'est un ensemble (répétition interdite) qui liste les éléments dans un ordre stable.
+     * La doc de java.util a propos de AbstractSet (ancêtre de LinkedHashSet)
+     * (...) all of the methods and constructors in subclasses of this class must obey the additional
+     * constraints imposed by the Set interface (for instance, the add method must not permit addition 
+     * of multiple instances of an object to a set). 
+     */
+   	private LinkedHashSet<Carte> contenu = new LinkedHashSet<Carte>();
+    
+    /**
+     * nbre de Cartes de l'ensemble.
+     * 
+     */
+    private int nbreCarte;
+
+    /**
+    * Constructeur d'Ensemble vide.
+    */
+    public EnsembleCarte(){
+        this.nbreCarte=0;
+    }
+
+    /**
+     * Ajoute une carte à l'ensemble.
+     * @param  c une carte
+     * @return true si la carte est ajoutée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble  
+     */
+    protected boolean add(Carte c){
+        this.nbreCarte++;
+        return contenu.add(c); 
+    }
+
+    /**
+     * Enlève une carte à l'ensemble.
+     * @param  c une carte
+     * @return true si la carte est retirée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être enlevéé car elle n'est pas présente dans l'ensemble  
+     */
+    private boolean remove(Carte c){
+        this.nbreCarte++;
+        return contenu.remove(c); 
+    }
+
+    /**
+     * Permet de transférer une paire de carte (par exemple depuis la table vers un joueur)
+     * Si ces cartes sont toutes les deux visibles
+     * @param  target destination du transfert
+     * @param  c1     première carte
+     * @param  c2     seconde carte
+     * @return        true en cas de succès, false sinon
+     * @throws NullPointerException si un élément passé en paramètre est null.
+     * @throws IllegalArgumentException si les cartes ne sont pas toutes les deux visibles
+     * @throws IllegalStateException si this ne contient pas les deux cartes.
+     */
+    public boolean transfer(EnsembleCarte target, Carte c1, Carte c2){
+    	return this.contenu.contains(c1) && this.contenu.remove(c1) && target.add(c1) && this.contenu.contains(c2) && this.contenu.remove(c2) && target.add(c2);
+    }	
+
+
+    public String toString(){
+        // Stringbuilder is the most efficient method of building a String like datastructure incrementally. 
+        StringBuilder sb = new StringBuilder(" de taille " + this.contenu.size() + ", contenant : \n");
+        for (Carte c : this.contenu){
+            sb.append(" _ " + c.toString() +"\n");
+        }
+        return sb.toString();
+    }
+
+
+    // tests obsolètes [serait OK si classe n'était pas abstraite]
+    
+    // public static void main(String[] args) {
+        
+    //     Carte un = new Carte(1);
+    //     Carte deux = new Carte (2);
+    //     deux.toggleVisible();
+    //     Carte unBis = new Carte(1);
+
+    //     Carte deuxBis = new Carte(2);
+
+    //     EnsembleCarte e1 = new EnsembleCarte();
+    //     System.out.println(e1.add(un) && e1.add(deux));
+    //     System.out.println(e1.toString());
+
+    //     EnsembleCarte e2 = new EnsembleCarte();
+    //     System.out.println(e2.add(un) && e2.add(unBis));
+    //     System.out.println(e2.toString());
+        
+    //     e1.transfer(e2,un,deuxBis);
+    //     System.out.println(e1.toString());
+    //     System.out.println(e2.toString());   
+        
+    // }
+}
+
+

DEV2.1/TP8/v0/Joueur.java

@@ -0,0 +1,95 @@
+import java.util.LinkedHashSet;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+/**
+ * Classe servant à représenter le joueur dans le modèle.
+ * Pour l'instant juste un nom et un ensemble de cartes
+ */
+public class Joueur extends EnsembleCarte {
+    /**
+    * Nom du joueur
+    */
+    private String nom;
+    
+    /**
+     * Constructeur
+     * @param  nom Futur nom du joueur, ne doit pas être null
+     * @throws nullPointerException si nom est null.
+     */
+    public Joueur(String nom){
+        this.nom=nom;
+    }
+
+    public String toString(){
+        return "Joueur " + this.nom + " " + super.toString();
+    }
+
+
+    public static void main(String[] args) {
+        // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+        // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard).
+
+        // Les Joueurs
+        Joueur toto = new Joueur("Toto");
+        Joueur titi = new Joueur("Titi");
+        Joueur tata = new Joueur("Tata");
+        
+        // Les cartes
+        Carte un = new Carte(1);
+        Carte deux = new Carte (2);
+        Carte unBis = new Carte(1);
+        Carte deuxBis = new Carte(2);
+
+        // la Table
+        Table t = new Table();
+        t.add(un);
+        t.add(deux);
+        t.add(unBis);
+        t.add(deuxBis);
+
+        System.out.println(t);
+        System.out.println(toto);
+
+        t.reveler(un);
+        t.reveler(unBis);
+
+        t.transfer(toto,un,unBis);
+        
+        System.out.println(t);
+        System.out.println(toto);	
+    }
+}
+
+

DEV2.1/TP8/v0/Table.java

@@ -0,0 +1,123 @@
+import java.util.LinkedHashSet;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+
+
+/**
+ * Classe gérant la table de jeu du Memory dans le modèle
+ * Pour l'instant ne gère pas le tour des joueurs.
+ * Devrait probablement le faire un jour.
+ */
+public class Table extends EnsembleCarte {
+       
+    /**
+     * Constructeur de Table vide (seul constructeur pour l'instant)
+     */
+    public Table(){
+    }
+
+    /**
+     * Nécessaire de la rendre publique car on a un parti pris que on commence avec une table vide à laquelle on ajoute des cartes.
+     * On pourrait alternativement faire un constructeur qui fabrique les cartes ou bien qui prend une collection de cartes.
+     * Ça n'aurait pas la vertu pédagogique de montrer qu'on peut surcharger une méthode en élevant les droits en java.
+     * 
+     * Par délégation mais en rendant publique la méthode (pour l'initialisation en fait).
+     * @param  c Carte à ajou
+     * @return true si la carte est ajoutée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble  
+     */
+    @Override
+    public boolean add(Carte c){
+        return super.add(c);
+    }
+
+    /**
+     * révèle une carte.
+     * @param c une carte à révèler
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalArgumentException si la carte n'est pas sur la table
+     * @throws IllegalStateException si la carte est déjà révélée 
+     */
+    public void reveler(Carte c){
+        c.toggleVisible(); 
+    }
+
+	/**
+     * cache une carte.
+     * @param c une carte à cacher
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalArgumentException si la carte n'est pas sur la table
+     * @throws IllegalStateException si la carte est déjà cachée 
+     */
+    public void cacher(Carte c){
+        c.toggleVisible(); 
+    }
+
+
+    public String toString(){
+        return "Table " + super.toString();
+    }
+
+
+    public static void main(String[] args) {
+        // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+        // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard).
+
+        // Les cartes
+        Carte un = new Carte(1);
+        Carte deux = new Carte (2);
+        Carte unBis = new Carte(1);
+        Carte deuxBis = new Carte(2);
+
+
+        // la Table
+        Table t = new Table();
+        t.add(un);
+        t.add(deux);
+        t.add(unBis);
+        t.add(deuxBis);
+
+        System.out.println(t);
+
+        t.reveler(un);
+        t.reveler(unBis);
+        
+        System.out.println(t);
+                
+    }
+}
+
+

DEV2.1/TP8/v0/TestCarte.java

@@ -0,0 +1,85 @@
+import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse; // 
+import org.junit.Test;
+
+
+/**
+ * Une classe pour faire des tests sur la classe Carte avec JUnit
+ */
+public class TestCarte {
+
+    // un test pour Junit4 c'est une méthode avec l'annotation @Test devant une méthode avec un type de retour void.
+    @Test
+    public void egaleSiIdentiquesEtVisible() {
+        Carte un = new Carte(1);
+        un.toggleVisible();
+         // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle)
+        assertTrue(un.egale(un));
+    }
+
+    // le nom du test doit être le plus explicite possible
+    @Test
+    public void egalSiMemeValeurEtVisible() {
+       Carte un = new Carte(1);
+       un.toggleVisible();
+       Carte unBis = new Carte(1);
+       unBis.toggleVisible();
+       assertTrue(un.egale(unBis));
+    }
+
+    @Test
+    public void pasEgalSiPasMemeValeurEtVisible() {
+       Carte un = new Carte(1);
+       un.toggleVisible();
+       Carte deux = new Carte(2);
+       deux.toggleVisible();
+       assertFalse(un.egale(deux));
+    }
+
+    // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = NullPointerException.class)
+    public void egalPasFaitPourNull(){
+        Carte bad = null;
+        Carte un = new Carte(1);
+        un.egale(bad);
+    }
+
+    // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = IllegalArgumentException.class)
+    public void egalPasFaitPourParametreNonVisible(){
+        Carte un = new Carte(1);
+         un.toggleVisible();
+        Carte deux = new Carte(2);
+        un.egale(deux);
+    }
+
+    // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = IllegalStateException.class)
+    public void egalPasFaitPourCarteThisNonVisible(){
+        Carte un = new Carte(1);
+        Carte deux = new Carte(2);
+        deux.toggleVisible();    
+        un.egale(deux);
+    }
+
+    //Le monde est mal fait et parfois c'est le test qui est faux.
+    //Notez que je suis vraiment méchant car ce test est satisfait au début avec le code proposé...
+    //Moralité : faites des tests très simples et faites vous relire! 
+    @Test 
+    public void egalTestMalFait(){
+        Carte un = new Carte(1);
+        un.toggleVisible();
+        Carte deux = new Carte(2);
+        deux.toggleVisible();
+        un.toggleVisible();//copié collé de la mort
+        assertFalse(un.egale(deux));
+    }
+
+    // si on ne met pas l'annotation arobase test, le test n'est jamais pris en compte.
+    // c'est juste une méthode annexe qui n'est pas appellée comme dans n'importe quelle classe.
+    public void autreTestMalFait(){
+        assertFalse(true);
+    }
+    
+     
+}

DEV3.1/TP2:Transitions/Galerie/Changement.java

@@ -0,0 +1,23 @@
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+public class Changement{
+		
+		static public void fenetreCliquer(int LR){
+		Main.pan.remove(Listeimage.liste[Listeimage.index]);
+		if (LR==1){
+			Listeimage.index+=1;
+			if(Listeimage.index==-1){
+				Listeimage.index=5;
+			}
+		}else {
+			Listeimage.index-=1;
+			if(Listeimage.index==6){
+				Listeimage.index=0;
+			}
+		}
+		Main.pan.add(Listeimage.liste[Listeimage.index]);
+		Main.pan.repaint();
+	}
+}

DEV3.1/TP2:Transitions/Galerie/Galerie.java

@@ -0,0 +1,32 @@
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+
+public class Galerie extends JPanel implements MouseListener{
+
+	public Galerie(){
+		super();
+	}
+
+	public void mouseClicked(MouseEvent e){
+		int x = e.getX();
+		if (x <= this.getWidth()/5){
+			Changement.fenetreCliquer(0);
+		}else if(x >= (this.getWidth()/5)*4){
+			Changement.fenetreCliquer(1);
+		}
+	}
+	
+	public void mouseEntered(MouseEvent evenement){
+	}
+	
+	public void mouseExited(MouseEvent evenement){
+	}
+	
+	public void mousePressed(MouseEvent evenement){
+	}
+	
+	public void mouseReleased(MouseEvent evenement){
+	}
+}

DEV3.1/TP2:Transitions/Galerie/Listeimage.java

@@ -0,0 +1,15 @@
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+
+public class Listeimage{
+
+		static JLabel image1 = new JLabel(new ImageIcon("image1.jpg"));
+		static JLabel image2 = new JLabel(new ImageIcon("image2.jpg"));
+		static JLabel image3 = new JLabel(new ImageIcon("image3.jpg"));
+		static JLabel image4 = new JLabel(new ImageIcon("image4.jpg"));
+		static JLabel image5 = new JLabel(new ImageIcon("image5.jpg"));
+		static JLabel[] liste = {image1, image2, image3, image4, image5};
+		static int index=0;
+}

DEV3.1/TP2:Transitions/Galerie/Main.java

@@ -0,0 +1,20 @@
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+public class Main{
+		
+		static JFrame fenetre = new JFrame();
+		static Galerie pan = new Galerie();
+
+		public static void main(String[] args) {
+
+		pan.add(Listeimage.image1);
+		fenetre.setSize(250, 250);
+    	fenetre.setLocation(250, 250);
+    	fenetre.addMouseListener(pan);
+    	fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		fenetre.setContentPane(pan);
+		fenetre.setVisible(true);
+	}
+}

SAE

@@ -1 +0,0 @@
-Subproject commit 12188daa2226d67c8e71cacb6b2d8e635cb12d4c

Vote.java

@@ -0,0 +1,20 @@
+import java.awt.*;
+import java.sql.*;
+
+public class Vote{
+	public static void main(String[] args) {
+		try{
+			Class.forName("org.mariadb.jdbc.Driver");
+			try{
+				Connection cnx = new DriverManager.getConnection("jdbc:mariadb://dwarves.arda.lan/pourchot","pourchot","A1B2C3");		
+				try{
+					PreparedStatement ps=cnx.prepareStatement("SELECT (");
+				}catch(SQLException){
+					cnx.close();
+				}
+			}catch(SQLException){
+			}
+		}catch(ClassNotFoundException){
+		}
+	}
+}