This commit is contained in:
Laureηt 2023-06-20 21:03:42 +02:00
commit edb95af291
Signed by: Laurent
SSH key fingerprint: SHA256:kZEpW8cMJ54PDeCvOhzreNr4FSh6R13CMGH/POoO8DI
11 changed files with 1052 additions and 0 deletions

7
.vscode/settings.json vendored Normal file
View file

@ -0,0 +1,7 @@
{
"java.project.referencedLibraries": [
"lib/**/*.jar",
"/usr/share/java/hamcrest-core.jar",
"/usr/share/java/junit.jar"
]
}

233
Cercle.java Normal file
View file

@ -0,0 +1,233 @@
import java.awt.Color;
/**
* Cercle modélise un cercle géométrique dans un plan équipé d'un
* repère cartésien. Un cercle peut être affiché et translaté.
*/
public class Cercle implements Mesurable2D {
//@ public invariant getRayon() > 0;
//@ public invariant getDiametre() > 0;
//@ private invariant rayon == getRayon();
//@ private invariant 2*rayon == getDiametre();
//@ private invariant couleur == getCouleur();
//@ private invariant centre.getX() == getCentre().getX();
//@ private invariant centre.getY() == getCentre().getY();
// Constantes
/** constante mathématique π. */
public static final double PI = Math.PI;
// Attributs
/** centre du cercle. */
private Point centre;
/** rayon du cercle. */
private double rayon;
/** couleur du cercle. */
private Color couleur = Color.BLUE;
// Constructeurs
/**
* Construire un cercle à partir de son centre et de son rayon.
* @param centre centre du cercle
* @param rayon rayon du cercle
*/
//@ requires centre != null;
//@ requires rayon > 0;
public Cercle(Point centre, double rayon) {
assert centre != null;
assert rayon > 0;
this.centre = new Point(centre.getX(),
centre.getY());
this.rayon = rayon;
}
/**
* Construire un cercle à partir de deux points diamétralement opposés.
* @param p1 point n°1
* @param p2 point n°2
*/
//@ requires p1 != null;
//@ requires p2 != null;
//@ requires p1.getX() != p2.getX() && p1.getY() != p2.getY();
//@ ensures getRayon() > 0;
public Cercle(Point p1, Point p2) {
assert p1 != null;
assert p2 != null;
assert p1.getX() != p2.getX()
|| p1.getY() != p2.getY();
this.centre = new Point((p1.getX() + p2.getX()) / 2,
(p1.getY() + p2.getY()) / 2);
this.rayon = p1.distance(p2) / 2;
}
/**
* Construire un cercle coloré à partir de deux points diamétralement opposés.
* @param p1 point n°1
* @param p2 point n°2
* @param couleur couleur du cercle
*/
//@ requires couleur != null;
public Cercle(Point p1, Point p2, Color couleur) {
this(p1, p2);
assert couleur != null;
this.couleur = couleur;
}
// GETs
/**
* Obtenir le rayon du cercle.
* @return rayon du cercle
*/
//@ ensures \result > 0;
public /*@ pure @*/ double getRayon() {
return this.rayon;
}
/**
* Obtenir le diamètre du cercle.
* @return diamètre du cercle
*/
//@ ensures \result > 0;
public /*@ pure @*/ double getDiametre() {
return 2 * this.rayon;
}
/**
* Obtenir le centre du cercle.
* @return centre du cercle
*/
public /*@ pure @*/ Point getCentre() {
return new Point(this.centre.getX(),
this.centre.getY());
}
/**
* Obtenir la couleur du cercle.
* @return couleur du cercle
*/
public /*@ pure @*/ Color getCouleur() {
return this.couleur;
}
// SETs
/**
* Changer le rayon du cercle.
* @param rayon nouveau rayon
*/
//@ requires rayon > 0;
//@ ensures getRayon() == rayon
public void setRayon(double rayon) {
assert rayon > 0;
this.rayon = rayon;
}
/**
* Changer le diamètre du cercle.
* @param d nouveau diamètre
*/
//@ requires d > 0;
//@ ensures getDiametre() == d
public void setDiametre(double d) {
assert d > 0;
this.rayon = d / 2;
}
/**
* Changer le centre du cercle.
* @param centre nouveau centre
*/
//@ requires centre != null;
public void setCentre(Point centre) {
assert centre != null;
this.centre = centre;
}
/**
* Changer la couleur du cercle.
* @param nouvelleCouleur nouvelle couleur
*/
//@ requires nouvelleCouleur != null;
public void setCouleur(Color nouvelleCouleur) {
assert nouvelleCouleur != null;
this.couleur = nouvelleCouleur;
}
// Prints
/**
* Convertir le Cercle en un String pour son affichage.
* @return String associée au Cercle
*/
public String toString() {
return "C" + this.rayon
+ "@" + this.centre;
}
/**
* Afficher le cercle.
*/
public void afficher() {
System.out.print(this);
}
// Méthodes
/**
* Translater le cercle.
* @param dx déplacement suivant l'axe des X
* @param dy déplacement suivant l'axe des Y
*/
public void translater(double dx, double dy) {
this.centre.translater(dx, dy);
}
/**
* Vérifier si un point est à l'intérieur du cercle.
* @param p point que l'on souhaite tester
* @return true si p 𝒞
*/
//@ requires p != null;
public boolean contient(Point p) {
assert p != null;
return p.distance(this.centre) <= this.rayon;
}
/**
* Renvoie le périmètre du cercle.
* @return perimètre du cercle
*/
public double perimetre() {
return 2 * PI * this.rayon;
}
/**
* Renvoie l'aire du cercle.
* @return aire du cercle
*/
public double aire() {
return PI * this.rayon * this.rayon;
}
// Méthodes de classe
/**
* Renvoie un Cercle créé à partir du centre et d'un point du cercle.
* @param centre centre du Cercle
* @param circ Point situé sur le cercle
* @return objet Cercle
*/
//@ requires centre != null;
//@ requires circ != null;
public static Cercle creerCercle(Point centre, Point circ) {
assert centre != null;
assert circ != null;
return new Cercle(centre, centre.distance(circ));
}
}

105
CercleTest.java Normal file
View file

@ -0,0 +1,105 @@
import org.junit.*;
import java.awt.Color;
import static org.junit.Assert.*;
/**
* Programme de test de la classe Cercle.
*/
public class CercleTest {
public static final double EPSILON = 1e-6;
// précision pour la comparaison entre réels.
/** Vérifier si deux points ont mêmes coordonnées.
* @param p1 le premier point
* @param p2 le deuxième point
*/
static void memesCoordonnees(Point p1, Point p2) {
assertEquals(p1.getX(), p2.getX(), EPSILON);
assertEquals(p1.getY(), p2.getY(), EPSILON);
}
private Point p_0 = new Point(0, 0);
private Point p_pp = new Point(3, 4);
private Point p_pm = new Point(3, -4);
private Point p_mm = new Point(-3, -4);
private Point p_mp = new Point(-3, 4);
private Cercle[] c12a = {new Cercle(p_pp, p_mm),
new Cercle(p_pm, p_mp),
new Cercle(p_mp, p_pm),
new Cercle(p_mm, p_pp)};
private Cercle[] c12b = {new Cercle(p_pp, p_pm),
new Cercle(p_pm, p_mm),
new Cercle(p_mm, p_mp),
new Cercle(p_mp, p_pp)};
private Cercle[] c13 = {new Cercle(p_pp, p_mm, Color.RED),
new Cercle(p_pm, p_mp, Color.GREEN),
new Cercle(p_mp, p_pm, Color.WHITE),
new Cercle(p_mm, p_pp, Color.BLACK)};
private Cercle[] c14 = {Cercle.creerCercle(p_0, p_pp),
Cercle.creerCercle(p_0, p_pm),
Cercle.creerCercle(p_0, p_mp),
Cercle.creerCercle(p_0, p_mm)};
@Test
public void testE12a() {
for (Cercle c : c12a) {
assertNotNull(c);
assertEquals(5, c.getRayon(), EPSILON);
assertEquals(10, c.getDiametre(), EPSILON);
memesCoordonnees(p_0, c.getCentre());
assertTrue(c.getCouleur() == Color.BLUE);
}
}
@Test
public void testE12b() {
for (Cercle c : c12b) {
assertNotNull(c);
assertTrue(c.getCouleur() == Color.BLUE);
}
assertEquals(4, c12b[0].getRayon(), EPSILON);
assertEquals(8, c12b[0].getDiametre(), EPSILON);
assertEquals(3, c12b[1].getRayon(), EPSILON);
assertEquals(6, c12b[1].getDiametre(), EPSILON);
assertEquals(4, c12b[2].getRayon(), EPSILON);
assertEquals(8, c12b[2].getDiametre(), EPSILON);
assertEquals(3, c12b[3].getRayon(), EPSILON);
assertEquals(6, c12b[3].getDiametre(), EPSILON);
memesCoordonnees(new Point(3, 0), c12b[0].getCentre());
memesCoordonnees(new Point(0, -4), c12b[1].getCentre());
memesCoordonnees(new Point(-3, 0), c12b[2].getCentre());
memesCoordonnees(new Point(0, 4), c12b[3].getCentre());
}
@Test
public void testE13() {
for (Cercle c : c13) {
assertNotNull(c);
assertEquals(5, c.getRayon(), EPSILON);
assertEquals(10, c.getDiametre(), EPSILON);
memesCoordonnees(p_0, c.getCentre());
}
assertTrue(c13[0].getCouleur() == Color.RED);
assertTrue(c13[1].getCouleur() == Color.GREEN);
assertTrue(c13[2].getCouleur() == Color.WHITE);
assertTrue(c13[3].getCouleur() == Color.BLACK);
}
@Test
public void testE14() {
for (Cercle c : c14) {
assertNotNull(c);
assertEquals(5, c.getRayon(), EPSILON);
assertEquals(10, c.getDiametre(), EPSILON);
memesCoordonnees(p_0, c.getCentre());
assertTrue(c.getCouleur() == Color.BLUE);
}
}
}

View file

@ -0,0 +1,95 @@
import org.junit.*;
import java.awt.Color;
import static org.junit.Assert.*;
/**
* Programme de test de la classe Cercle.
*/
public class ComplementsCercleTest {
public static final double EPSILON = 1e-6;
// précision pour la comparaison entre réels.
private Point p0 = new Point(0, 0);
private Point p1 = new Point(3, 4);
private Point p2 = new Point(-3, -4);
private Cercle c1;
private Cercle c2;
private Cercle c3;
private Cercle c4;
@Before
public void setUp() {
c1 = new Cercle(p0, 1);
c2 = new Cercle(p1, p2);
c3 = new Cercle(p1, p2, Color.MAGENTA);
c4 = Cercle.creerCercle(p0, p1);
}
@Test
public void testSetRayon() {
c1.setRayon(10);
assertEquals(10, c1.getRayon(), EPSILON);
assertEquals(20, c1.getDiametre(), EPSILON);
c2.setRayon(10);
assertEquals(10, c2.getRayon(), EPSILON);
assertEquals(20, c2.getDiametre(), EPSILON);
}
@Test
public void testSetDiametre() {
c1.setDiametre(20);
assertEquals(20, c1.getDiametre(), EPSILON);
assertEquals(10, c1.getRayon(), EPSILON);
c3.setDiametre(20);
assertEquals(20, c3.getDiametre(), EPSILON);
assertEquals(10, c3.getRayon(), EPSILON);
}
@Test
public void testSetCouleur() {
c1.setCouleur(Color.RED);
c3.setCouleur(Color.ORANGE);
assertEquals(Color.RED, c1.getCouleur());
assertEquals(Color.ORANGE, c3.getCouleur());
}
@Test
public void testSetCentre() {
c1.setCentre(new Point(10, 10));
assertEquals(10, c1.getCentre().getX(), EPSILON);
assertEquals(10, c1.getCentre().getY(), EPSILON);
}
@Test
public void testTranslater() {
c1.translater(100, 100);
assertEquals(100, c1.getCentre().getX(), EPSILON);
assertEquals(100, c1.getCentre().getY(), EPSILON);
c1.translater(-50, -150);
assertEquals( 50, c1.getCentre().getX(), EPSILON);
assertEquals(-50, c1.getCentre().getY(), EPSILON);
}
@Test
public void testContient() {
assertTrue(c4.contient(p0));
assertTrue(c4.contient(p1));
assertTrue(c4.contient(p2));
}
@Test
public void testPerimetre() {
assertEquals(2*Math.PI, c1.perimetre(), EPSILON);
assertEquals(10*Math.PI, c2.perimetre(), EPSILON);
}
@Test
public void testAire() {
assertEquals(Math.PI, c1.aire(), EPSILON);
assertEquals(25*Math.PI, c2.aire(), EPSILON);
}
}

191
FormeCercleTest.java Normal file
View file

@ -0,0 +1,191 @@
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
}
}
}

49
LISEZ-MOI.txt Normal file
View file

@ -0,0 +1,49 @@
Nom : FAINSIN
Prénom : Laurent
Groupe TP : I
Consigne : Ci-dessous, répondre à la place des « ... ».
=====[ Temps ]==================================================================
Temps consacré au projet pour rendre la V1 : 05 heures 00 minutes
Temps consacré au projet pour rendre la V2 : 00 heures 15 minutes
Pour la V2 on ne tiendra pas compte du temps passé sur la V1.
Bien sûr, Les temps renseignés ici ne sont pas pris en compte dans la notation.
=====[ Questions ]==============================================================
Indiquer la relation UML entre Cercle et le Point centre du cercle.
-------------------------------------------------------------------
Il y a une relation de composition entre Cercle et Point.
Comment est réalisée l'exigence E18 ?
-------------------------------------
On rappelle E18 : "On ne doit pas pouvoir changer les caractéristiques dun
cercle sans passer par les opérations de modification que la classe propose
(translater, setRayon, setDiametre, setCouleur...)."
Dans un premier temps on restreint les modifications extérieures des attributs via
le mot-clé "private", placé devant leur déclaration. Cela force l'utilisateur de la
classe à utiliser les fonctions SETs (qui vérifient de plus la validité des nouvelles
valeurs).
De même, il faut faire attention à ce que l'on renvoie avec les fonctions GETS.
En effet si l'on souhaite renvoyer le point correspondant au centre du cercle,
il faut renvoyer une copie de celui-ci au lieu de renvoyer directement this.centre.
On fait cela puisque renvoyer un objet Point revient à renvoyer un pointeur vers
une structure de données, qui est modifiable.
=====[ Explications ]===========================================================
(Facultatif) Donner ici les explications supplémentaires utiles à la
compréhension du travail rendu.
...

17
Mesurable2D.java Normal file
View file

@ -0,0 +1,17 @@
/** Définir les propriétés d'un élément fermé du plan.
* @author Xavier Crégut
* @version 1.3
*/
public interface Mesurable2D {
/** Obtenir le perimètre de l'élément.
* @return le perimètre
*/
double perimetre();
/** Obtenir l'aire de l'élément.
* @return l'aire
*/
double aire();
}

95
Point.java Normal file
View file

@ -0,0 +1,95 @@
import java.awt.Color;
/** Point modélise un point géométrique dans un plan équipé d'un
* repère cartésien. Un point peut être affiché et translaté.
* Sa distance par rapport à un autre point peut être obtenue.
*
* @author Xavier Crégut <Prénom.Nom@enseeiht.fr>
*/
public class Point {
private double x; // abscisse
private double y; // ordonnée
private Color couleur; // couleur du point
/** Construire un point à partir de son abscisse et de son ordonnée.
* @param vx abscisse
* @param vy ordonnée
*/
public Point(double vx, double vy) {
this.x = vx;
this.y = vy;
this.couleur = Color.green;
}
/** Obtenir l'abscisse du point.
* @return abscisse du point
*/
public double getX() {
return this.x;
}
/** Obtenir l'ordonnée du point.
* @return ordonnée du point
*/
public double getY() {
return this.y;
}
/** Changer l'abscisse du point.
* @param vx nouvelle abscisse
*/
public void setX(double vx) {
this.x = vx;
}
/** Changer l'ordonnée du point.
* @param vy nouvelle ordonnée
*/
public void setY(double vy) {
this.y = vy;
}
public String toString() {
return "(" + this.x + ", " + this.y + ")";
}
/** Afficher le point. */
public void afficher() {
System.out.print(this);
}
/** Distance par rapport à un autre point.
* @param autre l'autre point
* @return distance entre this et autre
*/
public double distance(Point autre) {
return Math.sqrt(Math.pow(autre.x - this.x, 2)
+ Math.pow(autre.y - this.y, 2));
}
/** Translater le point.
* @param dx déplacement suivant l'axe des X
* @param dy déplacement suivant l'axe des Y
*/
public void translater(double dx, double dy) {
this.x += dx;
this.y += dy;
}
// Gestion de la couleur
/** Obtenir la couleur du point.
* @return la couleur du point
*/
public Color getCouleur() {
return this.couleur;
}
/** Changer la couleur du point.
* @param nouvelleCouleur nouvelle couleur
*/
public void setCouleur(Color nouvelleCouleur) {
this.couleur = nouvelleCouleur;
}
}

125
RobustesseCercleTest.java Normal file
View file

@ -0,0 +1,125 @@
import java.awt.Color;
import org.junit.*;
import static org.junit.Assert.*;
/** Classe de test pour la robustesse de la classe Cercle.
* @author Xavier Crégut <Prenom.Nom@enseeiht.fr>
*/
public class RobustesseCercleTest {
protected Cercle c1;
@Before public void setUp() {
c1 = new Cercle(new Point(1, 2), 10);
}
@Test
public void testerOptionEnableAssertion() {
try {
assert false;
} catch (AssertionError e) {
// C'est normal !
return;
} catch (Throwable e) {
// C'est pas normal !
}
fail("Il faut exécuter avec l'option -ea de java !");
}
@Test(expected=AssertionError.class)
public void testerE5a() {
this.c1.contient(null);
}
@Test(expected=AssertionError.class)
public void testerE10a() {
this.c1.setCouleur(null);
}
@Test(expected=AssertionError.class)
public void testerE11a() {
this.c1 = new Cercle(null, 10);
}
@Test(expected=AssertionError.class)
public void testerE11b() {
this.c1 = new Cercle(new Point(1, 2), -10);
}
@Test(expected=AssertionError.class)
public void testerE11c() {
this.c1 = new Cercle(new Point(1, 2), 0);
}
@Test(expected=AssertionError.class)
public void testerE12a() {
this.c1 = new Cercle(new Point(1, 2), null);
}
@Test(expected=AssertionError.class)
public void testerE12b() {
this.c1 = new Cercle(null, new Point(1, 2));
}
@Test(expected=AssertionError.class)
public void testerE12c() {
this.c1 = new Cercle(new Point(1, 2), new Point(1, 2));
}
@Test(expected=AssertionError.class)
public void testerE13a() {
this.c1 = new Cercle(new Point(1, 2), null, Color.red);
}
@Test(expected=AssertionError.class)
public void testerE13b() {
this.c1 = new Cercle(null, new Point(1, 2), Color.red);
}
@Test(expected=AssertionError.class)
public void testerE13c() {
this.c1 = new Cercle(new Point(1, 2), new Point(1, 2), Color.red);
}
@Test(expected=AssertionError.class)
public void testerE13d() {
this.c1 = new Cercle(new Point(1, 2), new Point(1, 2), null);
}
@Test(expected=AssertionError.class)
public void testerE14a() {
this.c1 = Cercle.creerCercle(new Point(1, 2), null);
}
@Test(expected=AssertionError.class)
public void testerE14b() {
this.c1 = Cercle.creerCercle(null, new Point(1, 2));
}
@Test(expected=AssertionError.class)
public void testerE14c() {
this.c1 = Cercle.creerCercle(new Point(1, 2), new Point(1, 2));
}
@Test(expected=AssertionError.class)
public void testerE16a() {
this.c1.setRayon(-10);
}
@Test(expected=AssertionError.class)
public void testerE16b() {
this.c1.setRayon(0);
}
@Test(expected=AssertionError.class)
public void testerE17a() {
this.c1.setDiametre(-10);
}
@Test(expected=AssertionError.class)
public void testerE17b() {
this.c1.setDiametre(0);
}
}

135
SujetCercleTest.java Normal file
View file

@ -0,0 +1,135 @@
import java.awt.Color;
import org.junit.*;
import static org.junit.Assert.*;
/**
* Classe de test (incomplète) de la classe Cercle.
* @author Xavier Crégut
* @version $Revision$
*/
public class SujetCercleTest {
// précision pour les comparaisons réelle
public final static double EPSILON = 0.001;
// Les points du sujet
private Point A, B, C, D, E;
// Les cercles du sujet
private Cercle C1, C2;
@Before public void setUp() {
// Construire les points
A = new Point(1, 2);
B = new Point(2, 1);
C = new Point(4, 1);
D = new Point(8, 1);
E = new Point(8, 4);
// Construire les cercles
C1 = new Cercle(A, 2.5);
C2 = new Cercle(new Point(6, 1), 2);
C2.setCouleur(Color.yellow);
}
/** Vérifier si deux points ont mêmes coordonnées.
* @param p1 le premier point
* @param p2 le deuxième point
*/
static void memesCoordonnees(String message, Point p1, Point p2) {
assertEquals(message + " (x)", p1.getX(), p2.getX(), EPSILON);
assertEquals(message + " (y)", p1.getY(), p2.getY(), EPSILON);
}
@Test public void testerE11C1() {
memesCoordonnees("E11 : Centre de C1 incorrect", A, C1.getCentre());
assertEquals("E11 : Rayon de C1 incorrect",
2.5, C1.getRayon(), EPSILON);
assertEquals(Color.blue, C1.getCouleur());
}
@Test public void testerE1() {
C1.translater(10, 20);
memesCoordonnees("E1 sur C1", new Point(11, 22), C1.getCentre());
C2.translater(3, -1);
memesCoordonnees("E1 sur C2", new Point(9, 0), C2.getCentre());
}
@Test public void testerE1negatifs() {
C2.translater(-10, -7);
memesCoordonnees("E1 sur C2", new Point(-4, -6), C2.getCentre());
}
@Test public void testerE2() {
memesCoordonnees("E2 sur C1", A, C1.getCentre());
memesCoordonnees("E2 sur C2", new Point(6, 1), C2.getCentre());
}
@Test public void testerE3() {
assertEquals("E3 sur C1", 2.5, C1.getRayon(), EPSILON);
assertEquals("E3 sur C2", 2.0, C2.getRayon(), EPSILON);
}
@Test public void testerE4() {
assertEquals("E4 sur C1", 5.0, C1.getDiametre(), EPSILON);
assertEquals("E4 sur C2", 4.0, C2.getDiametre(), EPSILON);
}
@Test public void testerE5() {
assertTrue("E5", C1.contient(A));
assertTrue("E5", C1.contient(B));
assertFalse("E5", C1.contient(C));
assertFalse("E5", C1.contient(D));
assertFalse("E5", C1.contient(E));
assertFalse("E5", C1.contient(C));
assertFalse("E5", C1.contient(new Point(3, 4)));
assertTrue("E5", new Cercle(D, 3).contient(E));
}
@Test public void testerE6() {
assertEquals("E6", 5*Math.PI, C1.perimetre(), EPSILON);
assertEquals("E6", 4*Math.PI, C2.perimetre(), EPSILON);
assertEquals("E6", 6.25*Math.PI, C1.aire(), EPSILON);
assertEquals("E6", 4*Math.PI, C2.aire(), EPSILON);
}
@Test public void testerE9() {
assertEquals("E9", Color.blue, C1.getCouleur());
assertEquals("E9", Color.yellow, C2.getCouleur());
}
@Test public void testerE10() {
C1.setCouleur(Color.red);
assertEquals("E10", Color.red, C1.getCouleur());
}
@Test public void testerToString() {
assertEquals("E15: toString() redéfinie ? Correctement ?",
"C2.5@(1.0, 2.0)", C1.toString());
}
@Test public void testerE16() {
C1.setRayon(10);
assertEquals(10, C1.getRayon(), EPSILON);
C1.setRayon(20);
assertEquals(20, C1.getRayon(), EPSILON);
}
@Test public void testerE17() {
C1.setDiametre(10);
assertEquals(5, C1.getRayon(), EPSILON);
C1.setDiametre(20);
assertEquals(10, C1.getRayon(), EPSILON);
}
@Test public void testerE18() {
C1.getCentre().translater(10, 20);
memesCoordonnees("E18 : erreur si translation du centre",
new Point(1, 2), C1.getCentre());
A.translater(10, 20);
memesCoordonnees("E18 : erreur si translation de A",
new Point(1, 2), C1.getCentre());
}
}

BIN
to-1sn-2020-pr-01-sujet.pdf Normal file

Binary file not shown.