forgor

DEV2.3/tp1/MainCapture.java

@@ -0,0 +1,17 @@
+public class MainCapture {
+    public static void main(String[] args) {
+        try 
+        {
+            arrErr();
+        } 
+        catch (Exception e) 
+        {
+            System.out.println("Erreur :(");
+        }
+    }
+
+    public static void arrErr()
+    {
+        System.out.println(8/0);
+    }
+}

DEV2.3/v0/Carte.java

@@ -0,0 +1,145 @@
+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");
+        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.3/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.3/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.3/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.3/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/Mises en pages/boutons.java

@@ -23,7 +23,7 @@ public class boutons
         gbc.fill = GridBagConstraints.BOTH;     // occupe tout l'espace de la plage
         gbc.anchor = GridBagConstraints.CENTER; // se place au centre de la plage
         gbc.weightx = 1.0;  // souhaite plus de largeur si possible
-        gbc.weighty = 1.0;    // n'a pas besoin de hauteur supplémentaire
+        gbc.weighty = 1.0;  // n'a pas besoin de hauteur supplémentaire
         fenetre.add(b1, gbc);
 
         JButton b2 = new JButton("2");
@@ -33,7 +33,7 @@ public class boutons
         gbc.gridheight = 2; // la plage de cellules englobe deux ligne
         gbc.fill = GridBagConstraints.BOTH;     // occupe  tout l'espace de la plage
         gbc.anchor = GridBagConstraints.CENTER; // se place au centre de la plage
-        gbc.weightx = 1.0;    // n'a pas besoin de largeur supplémentaire
+        gbc.weightx = 1.0;   // n'a pas besoin de largeur supplémentaire
         gbc.weighty = 1.0;  // souhaite plus de heuteur si possible
         fenetre.add(b2, gbc);
 

Junit4Exemples/AssertTests.java

@@ -0,0 +1,106 @@
+/**
+   Il y a en fait pleins d'assertions possibles.
+
+   voici un exemple faisant un petit tour de ce qui est possible que j'ai pris ici.
+   https://github.com/junit-team/junit4/wiki/Assertions
+
+   NB. hamcrest est un projet maintenant intégré à junit
+   (c'est un anagrame de matchers)
+
+ */
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.both;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.everyItem;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.sameInstance;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+
+import org.hamcrest.core.CombinableMatcher;
+import org.junit.Test;
+
+public class AssertTests {
+  @Test
+  public void testAssertArrayEquals() {
+    byte[] expected = "trial".getBytes();
+    byte[] actual = "trial".getBytes();
+    assertArrayEquals("failure - byte arrays not same", expected, actual);
+  }
+
+  @Test
+  public void testAssertEquals() {
+    assertEquals("failure - strings are not equal", "text", "text");
+  }
+
+  @Test
+  public void testAssertFalse() {
+    assertFalse("failure - should be false", false);
+  }
+
+  @Test
+  public void testAssertNotNull() {
+    assertNotNull("should not be null", new Object());
+  }
+
+  @Test
+  public void testAssertNotSame() {
+    assertNotSame("should not be same Object", new Object(), new Object());
+  }
+
+  @Test
+  public void testAssertNull() {
+    assertNull("should be null", null);
+  }
+
+  @Test
+  public void testAssertSame() {
+    Integer aNumber = Integer.valueOf(768);
+    assertSame("should be same", aNumber, aNumber);
+  }
+
+  // JUnit Matchers assertThat
+  @Test
+  public void testAssertThatBothContainsString() {
+    assertThat("albumen", both(containsString("a")).and(containsString("b")));
+  }
+
+  @Test
+  public void testAssertThatHasItems() {
+    assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
+  }
+
+  @Test
+  public void testAssertThatEveryItemContainsString() {
+    assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
+  }
+
+  // Core Hamcrest Matchers with assertThat
+  @Test
+  public void testAssertThatHamcrestCoreMatchers() {
+    assertThat("good", allOf(equalTo("good"), startsWith("good")));
+    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
+    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
+    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
+    assertThat(new Object(), not(sameInstance(new Object())));
+  }
+
+  @Test
+  public void testAssertTrue() {
+    assertTrue("failure - should be true", true);
+  }
+}

Junit4Exemples/Calculator.java

@@ -0,0 +1,30 @@
+
+/**
+   Calculator est une classe offrant une seule méthode qui évalue une somme, donnée sous la forme d'une chaîne de caractère listant des opérandes séparées par des +
+
+*/
+
+public class Calculator {
+
+    /**
+       somme les opérandes passées sous forme d'une chaîne de caractères et retourne le résultat sous forme d'entier.
+       @param expression : chaîne de caractères ("nombres" séparés par des + sans espaces), par exemple "42+3" ou encore "-42+42" (le moins unaire est autorisé).
+                           ici nombre est à comprendre au sens de  parseInt(java.lang.String)
+       @throws NumberFormatException : si l'expression n'est pas dans ce format (par exemple "x+2" ou " 1 +2" -- il y a des espaces -- ou encore "9999999990").
+     */    
+    public int evaluate(String expression) {
+        int sum = 0;
+        for (String summand: expression.split("\\+"))
+            sum += Integer.valueOf(summand);
+        return sum;
+    }
+
+    /**
+       Pour appeller cette super méthode depuis la ligne de commande (on ne regarde que le premier argument, les autres sont ignorés).
+ 
+     */   
+    public static void main(String[] args) {
+        Calculator calculator = new Calculator();
+        System.out.println(calculator.evaluate(args[0]));
+    }
+}

Junit4Exemples/CalculatorTest0.java

@@ -0,0 +1,30 @@
+import static org.junit.Assert.assertEquals; // import static : une facilité offerte par java5
+import org.junit.Test;
+
+/**
+  CalculatorTest0 est un premier exemple de test pour la classe Calculator utilisant junit4
+  Assert, ou comment vérifier qu'une méthode donne un résultat correct?
+
+  Remarque en passant, pour tester en ligne de commande (une fois les classes compilées), il faut faire
+  $java org.junit.runner.JUnitCore CalculatorTest0
+
+  Remarque, comme expliqué dans la doc de org.junit.runner.JUnitCore
+JUnitCore is a *facade* for running tests. It supports running JUnit 4 tests, JUnit 3.8.x tests, and mixtures. To run tests from the command line, run java org.junit.runner.JUnitCore TestClass1 TestClass2
+
+  Oh le joli design pattern. C'est cadeau.
+ */
+
+public class CalculatorTest0 {
+
+    
+    // un test pour Junit4 c'est une méthode avec l'annotation suivante devant la méthode.
+    @Test
+    public void evaluatesGoodExpression() {
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1+2+3");
+        // 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)
+        assertEquals(6, sum);
+    }
+
+
+}

Junit4Exemples/CalculatorTest1.java

@@ -0,0 +1,18 @@
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+/**
+  CalculatorTest1 est un exemple de test pour la classe Calculator utilisant junit4.
+  Comment vérifier qu'on lance bien une exception?
+ */
+
+public class CalculatorTest1 {
+
+    
+    // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = NumberFormatException.class) 
+    public void doesNotEvaluateBadExpression() {
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1 +2+3");//notez l'espace qui va génèrez une exception
+    }
+}

Junit4Exemples/CalculatorTest2.java

@@ -0,0 +1,48 @@
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+import org.junit.BeforeClass; // ne pas oublie de charger le fait qu'on veut l'annotation @BeforeClass
+import org.junit.AfterClass; 
+
+/**
+  
+   CalculatorTest2 est un exemple de test pour la classe Calculator utilisant junit4
+   Il réunit en fait les deux tests des 2 classes précédentes dans une seule classe.
+
+   Typiquement on a en effet tous les tests simples portant sur une classe "métier" regroupée dans une classe de test correspondante.
+   Avec les annotations, on peut factoriser des choses concernant tous ces tests. 
+
+ */
+
+public class CalculatorTest2 {
+    static Calculator calculator;
+
+    // On peut si on le souhaite faire un traitement avant tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). 
+    @BeforeClass
+    public static void setUp() {
+        System.out.println("Avant tous les tests");
+        calculator = new Calculator();
+    }
+    
+    @Test
+    public void evaluatesGoodExpression() {
+        System.out.println("Test evaluation bonne expression");
+        int sum = calculator.evaluate("1+2+3");
+        assertEquals(6, sum);
+    }
+
+
+    @Test(expected = NumberFormatException.class) 
+    public void doesNotEvaluateBadExpression() {
+        System.out.println("Test evaluation mauvaise expression");
+        int sum = calculator.evaluate("1 +2+3");
+    }
+    
+    // On peut si on le souhaite faire un traitement après tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). 
+    @AfterClass
+    public static void tearDown() {
+        System.out.println("Après tous les Test");
+        calculator = null;
+    }
+
+}

Junit4Exemples/CalculatorTest3.java

@@ -0,0 +1,20 @@
+import static org.junit.Assert.assertEquals; 
+import org.junit.Test;
+
+/**
+  CalculatorTest3 est un exemple de test pour la classe Calculator utilisant junit4 qui est volontairement non satisfait
+
+ */
+
+public class CalculatorTest3 {
+
+    
+    @Test
+    public void evaluatesGoodExpression() throws Exception{
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1+2+3");
+        assertEquals(42, sum);
+    }
+
+
+}

Junit4Exemples/Readme.txt

@@ -0,0 +1,43 @@
+Les fichiers et ce qu'ils illustrent
+
+Calculator.java         le fichier contenant la classe qu'on va prétendre couloir tester.
+
+CalculatorTest0.java    mon premier test avec Junit4 et assert          
+CalculatorTest1.java    mon second test avec Junit4 pour des exceptions
+CalculatorTest2.java    les deux précédents
+CalculatorTest3.java    un test volontairement non satisfait
+
+Jusqu'ici pour exécuter un test, on compile tous les fichiers (une fois le classpath correct) puis on fait :
+
+$java org.junit.runner.JUnitCore CalculatorTest0
+
+voir plusieurs classes de tests suite à suite, en faisant :
+
+$java org.junit.runner.JUnitCore CalculatorTest0 CalculatorTest1
+
+Des choses un peu plus avancées
+
+RunForestRun.java       un exemple de runner (alternative à la ligne de commande qui fait la même chose en java).
+TestParam.java          mon premier test avancé permettant d'exécuter un test simple sur une liste de paramètres.
+TestSuite.java          comment combiner plusieurs tests (par exemple si on veut tester plusieurs classes en même temps).
+AssertTests.java        Squelette de toutes les variantes d'assertion proposées par Junit4
+
+===
+
+Pour pouvoir utiliser ces tests à bon escients, il faut :
+_ avoir installé Junit4 (c'est un jar)
+_ faire ce qu'il faut au CLASSPATH pour que Junit4 soit dedans.
+
+Par exemple sur ma machine, j'ai plusieurs versions de junit:
+
+$ ls -l /usr/share/java/junit*
+-rw-r--r-- 1 root root 108762 mai   18  2012 /usr/share/java/junit-3.8.2.jar
+-rw-r--r-- 1 root root 313072 mars   8  2016 /usr/share/java/junit4-4.12.jar
+lrwxrwxrwx 1 root root     15 mars   8  2016 /usr/share/java/junit4.jar -> junit4-4.12.jar
+lrwxrwxrwx 1 root root     15 mai   18  2012 /usr/share/java/junit.jar -> junit-3.8.2.jar
+
+Du coup, j'ai fait en sorte que mon CLASSPATH contienne /usr/share/java/junit4.jar
+
+$ echo $CLASSPATH 
+.:/usr/lib/jvm/java-8-openjdk-amd64/lib:/usr/share/java/junit4.jar
+

Junit4Exemples/RunForestRun.java

@@ -0,0 +1,24 @@
+/**
+   
+   Alternative à la ligne de commande, on peut appeller le runner depuis java avec org.junit.runner.JUnitCore.runClasses
+qui retourne un objet de type Result qui modélise les résultats des tests.
+
+En particulier, on peut accéder à la liste des échecs -- un échec eest un objet Failure -- avec getFailures
+
+ */
+
+
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class RunForestRun {
+
+    public static void main(String[] args) {
+        final Result result = org.junit.runner.JUnitCore.runClasses(CalculatorTest0.class,CalculatorTest1.class,CalculatorTest3.class);
+        for (final Failure failure : result.getFailures()) {
+            System.out.println(failure.toString()); // affiche détail sur chaque échec
+        }
+        System.out.println(result.wasSuccessful()); // affiche true ssi aucune erreurs
+    }
+}

Junit4Exemples/TestParam.java

@@ -0,0 +1,47 @@
+/**
+   
+   Example d'utilisation d'un runner spécial : Parameterized.
+   
+   Ce runner permet de facilement itérer des tests similaires sur plusieurs choix de valeurs. 
+   
+
+ */
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+
+// l'annotation @RunWith propre aux runners
+@RunWith(Parameterized.class)
+public class TestParam {
+
+    // l'annotation @Parameters pour aller chercher les paramètres des tests (on itère sur des tuples d'objet)
+    @Parameters(name = "{index}: {0} = {2}")
+     public static Iterable<Object[]> data() {
+         return Arrays.asList(new Object[][] { { "1+2+3", 6 }, { "40+2", 42 },
+                 { "001+41", 42 }, { "0000", 0 }, { "999+-999", 0 } });
+     }
+
+    // les attributs qui correspondent aux éléments de nos tuples
+     private String expression;
+     private int res;
+
+    // le constructeur
+     public TestParam(String expression, int res) {
+         this.expression = expression;
+         this.res = res;
+     }
+
+    // le test qui va manger les paramètres qu'on vient de définir
+     @Test
+     public void evaluatesGoodExpressions() {
+         Calculator calculator=new Calculator();    
+         assertEquals(res, calculator.evaluate(expression));
+     }
+}

Junit4Exemples/TestSuite.java

@@ -0,0 +1,26 @@
+/**
+  Un runner spécial qui sert à créer une collection de tests.
+  Typiquement, on peut avoir une classe de tests unitaires pour chaque classe métier et une "suite de tests" qui va appeller tous les tests de classes ayant un lien (par exemple dans le même paquet).  
+
+  Ceci est de nouveau un test, qu'on peut exécuter en faisant par exemple dans une console
+  java org.junit.runner.JUnitCore TestSuite
+
+ */
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+// @RunWith permet d'indiquer le runner
+@RunWith(Suite.class)
+
+//les tests à faire et dans quel ordre.
+@Suite.SuiteClasses({
+  CalculatorTest0.class,
+  CalculatorTest1.class,
+  CalculatorTest3.class
+})
+
+public class TestSuite {
+  // La classe est vide en fait
+  // C'est juste un conteneur pour les annotations du dessus, utilisés par Junit4
+}