Upload files to 'ExamenTests'

ExamenTests/PileBornee.java

@@ -0,0 +1,85 @@
+import java.util.EmptyStackException;
+	/**
+	* Classe pouvant stocker un ensemble d'entier sous forme de pile
+	* On ne peut stocker que des entiers positifs
+	* La pile a une taille bornée donnée à la création de l'objet
+	* Toute case ne contenant pas un entier de la pile contient -1
+	*/
+public class PileBornee{
+
+	// La mémoire de notre pile
+	protected int[] t;
+	// Le remplissage de notre pile
+	protected int index;
+
+	// Crée une pile dont la taille est bornée par l'entier donné en entrée
+	public PileBornee(int n){
+		t=new int[n];
+		for(int i=0;i<n;i++){
+			t[i]=-1;
+		}
+		index=0;
+	}
+
+	/**
+	* La fonction push ajoute l'élément n à la pile
+	* @param n un entier positif
+	* @return void
+	* @throws IllegalArgumentException si l'entier est négatif
+	* @throws IllegalStateException si la pile est pleine
+	*/
+	public void push(int n){
+		this.t[this.index]=n;
+		this.index++;
+		}
+
+	/**
+	* Renvoie l'élément de sommet de la pile si elle est non vide
+	* @return int le sommet de la pile
+	* @throws EmptyStackException si la pile est vide
+	*/
+	public int pop() throws EmptyStackException{
+		if(this.vide()){
+			throw new EmptyStackException();
+		}
+		index--;
+		int res=this.t[this.index];
+		return res;
+	}
+
+	/**
+	* Dit si la pile est vide
+	* @return boolean vrai si la pile est vide, faux sinon
+	*/
+	public boolean vide(){
+		return this.index==0;
+	}
+
+	/**
+	* Renvoie vrai si la pile contient l'argument
+	* @param n int à chercher dans la pile
+	* @return boolean vrai si n est dans la pile, faux sinon
+	*/
+	public boolean contient(int n){
+		boolean res=false;
+		for(int i=0;i<this.index;i++){
+			if(n==this.t[i]){
+				return true;
+			}else{
+			return false;
+			}
+		}
+	}
+
+	// Surcharge de toString pour un affichage correct
+	@Override
+	public String toString(){
+		String res="[";
+		for(int i=0;i<this.index;i++){
+			res+=this.t[i]+",";
+		}
+		return res+"]";
+	}
+
+	}
+

ExamenTests/README.md

@@ -0,0 +1,41 @@
+# TP noté tests et debug.
+
+## Fichiers mis à disposition
+Pour ce TP noté sur les tests, vous disposez des fichiers suivants
+
++ README.md                          ce fichier, qui vous indique ce qu'il faut faire.
++ **PileBornee.java**                Une implémentation d'une pile d'entiers.
++ TestsFournisPileBornee.java         des tests fournis pour corriger PileBornee.java
++ **TestsACompleterPileBornee.java**  un fichier squelette de tests à compléter.
+
+Seuls les fichiers dont les noms sont **en gras** ci-dessus sont à compléter et à rendre.
+Pour les modalités, voir ci-dessous.
+
+## Première partie : debug ##
+Un certains nombres de tests sont fournis. Vous ne devez pas changer ces derniers.
+Vous devez exécuter ces tests puis changer le code de la classe **PileBornee** idéalement jusqu'à ce que les tests fournis soient satisfaits.
+
+Chaque ligne de **PileBornee.java** changée devra être suivi du commentaire //BUGFIX éventuellement suivi de texte
+
+Par exemple : 
+> return (this.index); //BUGFIX enlevé +1
+
+si vous avez enlevé +1.
+
+BUGFIX me permet de voir où vous avez modifié le code.
+Si vous ne suivez pas ces consignes vous n'aurez aucun point sur cette partie.
+
+## Seconde partie : test ##
+Vous devez compléter le fichier **TestsACompleterPileBornee.java**
+Il n'est pas demandé de changer le code de **PileBornee.java** pour passer ces nouveaux tests.
+
+## Modalité de rendu ##
+Vous devez envoyer par mail à luc.dartois@u-pec.fr avec comme objet : [TP Test] Nom Prenom
+
+Le mail devra contenir une archive tests.tar.gz contenant uniquement les deux fichiers .java (on ne veut pas les .class) suivants, édités par vos soins comme indiqué dans les questions ci-dessus :
+**PileBornee.java**
+**TestsACompleterPileBornee.java**
+
+Pour ceux qui ont oublié comment faire :
+
+> bob@box:~$ tar czvvf tests.tar.gz MonRanger.java TestsACompleterMonRanger.java 

ExamenTests/TestsACompleterPileBornee.java

@@ -0,0 +1,47 @@
+import static org.junit.Assert.assertTrue;   // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse;  //
+import static org.junit.Assert.assertEquals; //
+import static org.junit.Assert.assertNull;   //
+import static org.junit.Assert.assertNotNull;   // 
+import org.junit.Test;
+import java.lang.StringBuilder;
+import java.util.EmptyStackException;
+
+
+
+public class TestsACompleterPileBornee{
+
+	// Le pop renvoie le dernier push
+	@Test
+	public void PushEgalPop(){
+
+	}
+
+	// On ne peut pas pop si la pile est vide
+	@Test(expected = EmptyStackException.class)
+	public void NonPopSurPileVide(){
+
+	}
+
+
+	// La valeur de l'index correspond au nombre de push moins le nombre de pop
+	@Test
+	public void IndexVautNombreDePush(){
+
+	}
+
+	// Contient renvoie faux si n n'est pas dans la pile
+	@Test
+	public void NeContientPasCeQuonAPasMis(){
+	
+	}
+
+	// Contient renvoie faux si n a été dans la pile mais ne l'est plus
+	@Test
+	public void NeContientPLusCeQuonAEnleve(){
+		
+	}
+
+
+
+}

ExamenTests/TestsFournisPileBornee.java

@@ -0,0 +1,65 @@
+import static org.junit.Assert.assertTrue;   // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse;  //
+import static org.junit.Assert.assertEquals; //
+import static org.junit.Assert.assertNull;   //
+import static org.junit.Assert.assertNotNull;   // 
+import org.junit.Test;
+import java.lang.StringBuilder;
+import java.util.EmptyStackException;
+
+
+
+public class TestsFournisPileBornee{
+
+	// Une case vide contient forcement -1
+	@Test
+	public void CaseVideVautMoinsUn(){
+		PileBornee pb=new PileBornee(4);
+		pb.push(5);
+		pb.push(34);
+		pb.pop();
+		assertEquals(pb.t[3],-1);
+		assertEquals(pb.t[1],-1);
+	}
+
+
+	// On ne peut pas push si la pile est pleine
+	@Test(expected = IllegalStateException.class)
+	public void PushSurPilePleine(){
+		PileBornee pb=new PileBornee(26);
+		for(int i=0;i<26;i++){
+			pb.push(3*i);
+		}
+		pb.push(0);
+	}
+
+	//On ne peut pas push un nombre négatif
+	@Test(expected = IllegalArgumentException.class)
+	public void NonNegativeInteger(){
+				PileBornee pb=new PileBornee(5);
+				pb.push(-5);
+	}
+
+	// Contient renvoie vrai si n est dans la pile
+	@Test
+	public void ContientCeQuonAMis(){
+		PileBornee pb=new PileBornee(42);
+		pb.push(12);	
+		pb.push(1138);
+		pb.push(48);
+		pb.push(12);
+		assertTrue(pb.contient(12));
+		assertTrue(pb.contient(1138));
+	}
+
+	// toString renvoie un affichage correspondant à ce qu'on attend
+	@Test
+	public void AffichageCorrect(){
+		PileBornee pb=new PileBornee(12);
+		pb.push(1);
+		pb.push(2);
+		pb.push(3);
+		assertEquals("[1,2,3]",pb.toString());
+	}
+
+}