sayebabu/DEV
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

forgor

Browse Source
This commit is contained in:
Simon SAYE BABU 2023-10-05 10:37:11 +02:00
parent 0d553d9bfd
commit 1e3fad56ad
19 changed files with 1001 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
WEBBE/TP1/bonjour.php → DEV2.3/WEBBE/TP1/bonjour.php
View File

0
WEBBE/TP2/exo1.php → DEV2.3/WEBBE/TP2/exo1.php
View File

17
DEV2.3/tp1/MainCapture.java Normal file
View File

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

145
DEV2.3/v0/Carte.java Normal file
View File

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

142
DEV2.3/v0/EnsembleCarte.java Normal file
View File

@ -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());
// }
}

95
DEV2.3/v0/Joueur.java Normal file
View File

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

123
DEV2.3/v0/Table.java Normal file
View File

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

85
DEV2.3/v0/TestCarte.java Normal file
View File

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

106
Junit4Exemples/AssertTests.java Normal file
View File

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

30
Junit4Exemples/Calculator.java Normal file
View File

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

30
Junit4Exemples/CalculatorTest0.java Normal file
View File

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

18
Junit4Exemples/CalculatorTest1.java Normal file
View File

@ -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
}
}

48
Junit4Exemples/CalculatorTest2.java Normal file
View File

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

20
Junit4Exemples/CalculatorTest3.java Normal file
View File

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

43
Junit4Exemples/Readme.txt Normal file
View File

@ -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

24
Junit4Exemples/RunForestRun.java Normal file
View File

@ -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
}
}

47
Junit4Exemples/TestParam.java Normal file
View File

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

26
Junit4Exemples/TestSuite.java Normal file
View File

@ -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
}