projet-mini-programmation-o.../FormeCercleTest.java

192 lines
6 KiB
Java
Raw Normal View History

2023-06-20 19:03:42 +00:00
import java.awt.Color;
import java.lang.reflect.*;
import org.junit.*;
import static org.junit.Assert.*;
import java.util.*;
/**
* L'objectif de cette classe est de vérifier que la classe Cercle a été
* correctement programmée.
*
* @author Xavier Crégut
* @version $Revision$
*/
public class FormeCercleTest {
// précision pour les comparaisons réelle
public final static double EPSILON = 0.001;
final static private Class<Cercle> cercle = Cercle.class;
private static Method getMethode(Class<?> c, String name, Class<?>... types)
throws NoSuchMethodException
{
Method resultat = c.getMethod(name, types);
assertNotNull("méthode " + name + "(" + types + ") non déclarée !", resultat);
return resultat;
}
private void verifierTypeRetour(Method m, Class<?> expected)
{
// TODO : définir une méthode signatureToString() pour construire la
// signature de la méthode plutôt que d'utiliser getName
assertEquals("Erreur sur le type de retour de " + m.getName() + ".",
expected, m.getReturnType());
}
private static Field getAttribut(Class c, String name)
throws NoSuchFieldException
{
try {
return c.getDeclaredField(name);
} catch (NoSuchFieldException e) {
fail("attribut non déclaré : " + name);
return null; // jamais atteint
}
}
private static List<Field> getAttributsInstance(Class c) {
ArrayList<Field> result = new ArrayList<Field>(5);
for (Field f : c.getDeclaredFields()) {
if (! Modifier.isStatic(f.getModifiers())) {
result.add(f);
}
}
return result;
}
private static void verifierConstanteClasse(Class c, String name)
throws NoSuchFieldException
{
Field attr = getAttribut(c, name);
assertTrue(name + " : devrait être une constante !",
Modifier.isFinal(attr.getModifiers()));
assertTrue(name + " : doit être une constante de *classe* !",
Modifier.isStatic(attr.getModifiers()));
assertTrue(name + " : Pourquoi pas public ?",
Modifier.isPublic(attr.getModifiers()));
}
@Test public void testerE5() throws NoSuchMethodException {
// TODO : Il faudrait que getMethode signale le problème !
// On peut en effet construire le message à partir des paramètres reçus
Method contient = getMethode(cercle, "contient", Point.class);
verifierTypeRetour(contient, boolean.class);
}
@Test public void testerC12() throws Exception {
verifierConstanteClasse(cercle, "PI");
}
@Test public void testerC12ValeurPI() throws Exception {
Field pi = getAttribut(cercle, "PI");
pi.setAccessible(true);
assertTrue("Le type de PI doit être double",
double.class.equals(pi.getType()));
if (Modifier.isStatic(pi.getModifiers())) {
assertEquals("Pas d'utilisation de Math.PI pour initialiser PI ?",
Math.PI, pi.getDouble(null), 0.0);
} else {
Cercle c = new Cercle(new Point(1, 2), 10);
assertEquals("Pas d'utilisation de Math.PI pour initialiser PI ?",
Math.PI, pi.getDouble(c), 0.0);
}
}
@Test public void testerNombreAttributs() throws Exception {
int attendu = 3; // nombre d'attributs d'instance attendus
int nbReel = getAttributsInstance(cercle).size();
assertFalse("Trop d'attributs d'instance : " + nbReel
+ " au lieu de " + attendu + " !", nbReel > attendu);
assertFalse("Pas assez d'attributs d'instance : " + nbReel
+ " au lieu de " + attendu + " !", nbReel < attendu);
}
@Test public void testAttributsPrives() throws Exception {
for (Field f : cercle.getDeclaredFields()) {
if (! Modifier.isFinal(f.getModifiers())) {
if (! Modifier.isFinal(f.getModifiers())) {
assertFalse("L'attribut " + f.getName() + " ne devrait pas être public !",
Modifier.isPublic(f.getModifiers()));
assertFalse("Attribut " + f + " : Pourquoi protected ?",
Modifier.isPublic(f.getModifiers()));
assertTrue("Attribut " + f + " : Droit d'accès oublié ?",
Modifier.isPrivate(f.getModifiers()));
}
}
}
}
@Test public void testAttributsNomsAssezLongs() throws Exception {
for (Field f : cercle.getDeclaredFields()) {
String nom = f.getName();
assertTrue("C3: Nom trop court pour l'attribut " + nom, nom.length() > 1);
}
}
private final static Set<String> nomsPeuSiginificatifs;
static {
nomsPeuSiginificatifs = new TreeSet<String>();
Collections.addAll(nomsPeuSiginificatifs, "p1", "p2", "a", "b",
"point1", "point2", "c", "r", "c_aux");
}
@Test public void testAttributsNomsPeuSignificatifs() throws Exception {
for (Field f : cercle.getDeclaredFields()) {
String nom = f.getName();
assertFalse("C3: Nom pas assez significatif pour l'attribut " + nom,
nomsPeuSiginificatifs.contains(nom.toLowerCase()));
}
}
@Test public void testerE6() {
assertTrue("Cercle devrait être un Mesurable2D !",
Mesurable2D.class.isAssignableFrom(cercle));
}
@Test public void testerE6bis() {
boolean trouve = false;
for (Class<?> i : cercle.getInterfaces()) {
trouve = trouve || i == Mesurable2D.class;
}
assertTrue("Cercle doit directement réaliser Mesurable2D !", trouve);
}
@Test public void testerNbConstructeurs() {
int nbAttendu = 3;
int nbConstructeurs = cercle.getConstructors().length;
assertFalse("Trop de constructeurs : " + nbConstructeurs,
nbConstructeurs > nbAttendu);
assertFalse("Pas assez de constructeurs : " + nbConstructeurs,
nbConstructeurs < nbAttendu);
}
@Test public void testerE14() throws Exception {
Method creerCercle = null;
try {
creerCercle = getMethode(cercle, "creerCercle", Point.class,
Point.class);
} catch (NoSuchMethodException e) {
fail("La méthode creerCercle(Point, Point) n'existe pas !");
}
int modifieurs = creerCercle.getModifiers();
assertTrue("creerCercle devrait être publique !",
Modifier.isPublic(modifieurs));
assertTrue("creerCercle doit être une méthode de classe !",
Modifier.isStatic(modifieurs));
}
@Test public void testerContructeurDefaut() {
try {
Constructor<Cercle> defaut = cercle.getConstructor();
fail("Pourquoi définir un constructeur par défaut sur Cercle ?");
} catch (NoSuchMethodException e) {
// OK
}
}
}