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);
}
L’interface
Puissance indique quelles fonctionnalités doivent
être remplies par toutes ses classes filles.
La Documentation est générée automatiquement
par l’utilitaire
javadoc à partir des commentaires
laissés dans le code source.
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);
}
}
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.
package testsUnitaires;
public class TestBourrin
{
public static void main(String[] args)
{
Puissance p = new ImplementationPuissance();
System.out.println(p.puissance(2, 10));
}
}
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));
}
}
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);
}
}
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));
}
}
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);
}
}