pdf - e-book - archive - github.com

1.14  Tests unitaires


Voir les diapos


1.14.1  Exemple

Spécification

package testsUnitaires;

public interface Puissance
{
 /**
  * Retourne x + 1. x quelconque.
  */

 public int succ(int x);

 /**
  * Retourne x - 1. x quelconque.
  */

 public int pred(int x);

 /**
  * Retourne a + b. a et b quelconques.
  */

 public int somme(int a, int b);

 /**
  * Retourne a * b. a et b quelconques.
  */

 public int produit(int a, int b);

 /**
  * Retourne base^exp. 
  * base quelconque, exp positif ou nul.
  */

 public int puissance(int base, int exp);
}

Télécharger le fichier

L’interface Puissance indique quelles fonctionnalités doivent être remplies par toutes ses classes filles.

Javadoc

La Documentation est générée automatiquement par l’utilitaire javadoc à partir des commentaires laissés dans le code source.

Implémentation

Voici un exemple d’implémentation :

package testsUnitaires;

public class ImplementationPuissance implements Puissance
{
 public int succ(int x)
 {
  return x + 1;
 }

 public int pred(int x)
 {
  return -succ(-x);
 }

 public int somme(int a, int b)
 {
  if (b == 0)
   return a;
  if (b > 0)
   return somme(succ(a), pred(b));
  else
   return somme(pred(a), succ(b));
 }

 public int produit(int a, int b)
 {
  if (b == 0)
   return 0;
  if (b > 0)
   return somme(produit(a, pred(b)), a);
  else
   return somme(produit(a, succ(b)), -a);
 }

 public int puissance(int base, int exp)
 {
  if (exp == 0)
   return 1;
  if ((exp & 1) == 0)
   return puissance(produit(base, base), exp >> 1);
  return produit(puissance(base, pred(exp)), base);
 }
}

Télécharger le fichier

Comment s’assurer que ce code fonctionne correctement ?

Il existe en Java (et en programmation en général) plusieurs façons d’effectuer des tests.

1.14.2  Test à la bourrin

package testsUnitaires;

public class TestBourrin
{
 public static void main(String[] args)
 {
  Puissance p = new ImplementationPuissance();
  System.out.println(p.puissance(2, 10));
 }
}

Télécharger le fichier

1.14.3  Test des fonctions

package testsUnitaires;

public class TestFonctions
{
 public static void main(String[] args)
 {
  Puissance p = new ImplementationPuissance();
  System.out.println("2 = " + p.succ(1));
  System.out.println("5 = " + p.pred(6));
  System.out.println("2 = " + p.somme(2, 0));
  System.out.println("9 = " + p.somme(3, 6));
  System.out.println("10 = " + p.somme(13, -3));
  System.out.println("2 = " + p.produit(2, 1));
  System.out.println("18 = " + p.produit(3, 6));
  System.out.println("-18 = " + p.produit(-3, 6));
  System.out.println("1 = " + p.puissance(4, 0));
  System.out.println("5 = " + p.puissance(5, 1));
  System.out.println("9 = " + p.puissance(3, 2));
  System.out.println("1024 = " + p.puissance(2, 10));
 }
}

Télécharger le fichier

1.14.4  Test des fonctions automatisé

package testsUnitaires;

public class TestFonctionsAutomatique
{
 private boolean ok = true;

 private void teste(String fonction, int obtenu, int attendu)
 {
  if (attendu == obtenu)
   System.out.println("test OK");
  else
  {
   System.out.println("test " + fonction + " échoué : " + obtenu
     + " != " + attendu);
   ok = false;
  }
 }

 public boolean teste(Puissance p)
 {
  ok = true;
  try
  {
   teste("succ", p.succ(1), 2);
   teste("pred", p.pred(6), 5);
   teste("somme", p.somme(2, 0), 2);
   teste("somme", p.somme(3, 6), 9);
   teste("somme", p.somme(13, -3), 10);
   teste("produit", p.produit(2, 1), 2);
   teste("produit", p.produit(3, 6), 18);
   teste("produit", p.produit(-3, 6), -18);
   teste("produit", p.produit(3, -6), -18);
   teste("puissance", p.puissance(4, 0), 1);
   teste("puissance", p.puissance(5, 1), 5);
   teste("puissance", p.puissance(3, 2), 9);
   teste("puissance", p.puissance(2, 10), 1024);
  }
  catch (Exception e)
  {
   ok = false;
   System.out.println(e);
  }
  if (ok)
   System.out.println("----> Soooo goood");
  else
   System.out.println("----> Au moins un test a échoué.");
  return ok;
 }

 public static void main(String[] args)
 {
  Puissance p = new ImplementationPuissance();
  TestFonctionsAutomatique t = new TestFonctionsAutomatique();
  t.teste(p);
 }
}

Télécharger le fichier

1.14.5  Tests unitaires

package testsUnitaires;

import static org.junit.Assert.*;
import org.junit.Test;

public class TestsJUnit
{
 private Puissance p = new ImplementationPuissance();

 @Test
 public void testSucc()
 {
  assertEquals("test de la fonction successeur", 2, p.succ(1));
  assertEquals("test de la fonction successeur", -2, p.succ(-3));
  assertEquals("test de la fonction successeur", 1, p.succ(0));
 }

 @Test
 public void testPred()
 {
  assertEquals("pred", 5, p.pred(6));
  assertEquals("pred", -8, p.pred(-7));
  assertEquals("pred", -1, p.pred(0));
 }

 @Test
 public void testSomme()
 {
  assertEquals("somme", 2, p.somme(2, 0));
  assertEquals("somme", 2, p.somme(0, 2));
  assertEquals("somme", 9, p.somme(3, 6));
  assertEquals("somme", 10, p.somme(13, -3));
  assertEquals("somme", -10, p.somme(-13, 3));
  assertEquals("somme", -16, p.somme(-13, -3));
 }

 @Test
 public void testProduit()
 {
  assertEquals("produit", 0, p.produit(2, 0));
  assertEquals("produit", 0, p.produit(0, 2));
  assertEquals("produit", 2, p.produit(2, 1));
  assertEquals("produit", 18, p.produit(3, 6));
  assertEquals("produit", -18, p.produit(-3, 6));
  assertEquals("produit", 18, p.produit(-3, -6));
 }

 @Test
 public void testPuissance()
 {
  assertEquals("puissance", 1, p.puissance(4, 0));
  assertEquals("puissance", 5, p.puissance(5, 1));
  assertEquals("puissance", 1, p.puissance(1, 50));
  assertEquals("puissance", 9, p.puissance(3, 2));
  assertEquals("puissance", 1024, p.puissance(2, 10));
 }
}

Télécharger le fichier

1.14.6  Logs

package testsUnitaires;

import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

public class PuissanceAvecLog extends ImplementationPuissance
{
 private final static Logger LOGGER = Logger.getLogger(PuissanceAvecLog.class
   .getName());
 static
 {
  try
  {
   FileHandler handler = new FileHandler("log/puissance.log");
   LOGGER.addHandler(handler);
   handler.setFormatter(new SimpleFormatter());
  }
  catch (IOException e)
  {
   e.printStackTrace();
  }
 }

 @Override
 public int puissance(int base, int exp)
 {
  String str = "Call to puissance : " + base + "^" + exp + " = ";
  if (exp == 0)
   str += 1;
  else if ((exp & 1) == 0)
   str += "" + base * base + "^" + (exp >> 1);
  else
   str += "" + base + "*(" + base + "^" + (exp - 1) + ")";
  LOGGER.info(str);
  return super.puissance(base, exp);
 }
}

Télécharger le fichier