init

.vscode/settings.json

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

Cercle.java

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

CercleTest.java

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

ComplementsCercleTest.java

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

FormeCercleTest.java

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

LISEZ-MOI.txt

@@ -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 d’un
+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.
+
+...

Mesurable2D.java

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

Point.java

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

RobustesseCercleTest.java

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

SujetCercleTest.java

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