D:\HES\Conformité du SI\2008-20

/**
* Enseignements - Base de test.
*
* @author Peter DAEHNE
* @version 1.0
*/
import java.util.*;
Professeur p = getProf(profs[i]);
m.addProfesseur(p); p.addEnseignement(m);
}
} // defEns
private void définirEnseignements () {
defEns(611, new String[]{"XB", "JPQ"});
defEns(612, new String[]{"JPQ", "GB", "XB"});
defEns(613, new String[]{"GB", "JPQ", "PHD", "XB", "RH"});
defEns(614, new String[]{"GB", "JPQ", "PHD", "XB", "RH"});
defEns(621, new String[]{"MK", "RH", "CHS"});
defEns(622, new String[]{"MK", "RH", "CHS"});
defEns(623, new String[]{"MK", "PD"});
defEns(624, new String[]{"MK", "PD"});
} // définirEnseignements
public class Base {
/* Liste de professeurs */
private HashMap professeurs = créerProfesseurs();
private HashMap créerProfesseurs () {
HashMap p = new HashMap();
p.put("PD", new Professeur("Daehne", "Peter"));
p.put("JPT", new Professeur("Trabichet", "Jean-Philippe"));
p.put("PHD", new Professeur("Dugerdil", "Philippe"));
p.put("XB", new Professeur("Burdet", "Xavier"));
p.put("GB", new Professeur("Brentini", "Gilles"));
p.put("JPQ", new Professeur("Quinlan", "James-Patrick"));
p.put("EV", new Professeur("Viganò", "Enrico"));
p.put("RH", new Professeur("Hauri", "Rolf"));
p.put("MK", new Professeur("Kuhne", "Michel"));
p.put("CHS", new Professeur("Stettler", "Christian"));
return p;
} // créerProfesseurs
/* Liste de modules */
private HashMap modules = créerModules();
private HashMap créerModules () {
HashMap m = new HashMap();
m.put(new Integer(611), new Module(611,
m.put(new Integer(612), new Module(612,
m.put(new Integer(613), new Module(613,
m.put(new Integer(614), new Module(614,
m.put(new Integer(621), new Module(621,
m.put(new Integer(622), new Module(622,
m.put(new Integer(623), new Module(623,
m.put(new Integer(624), new Module(624,
return m;
} // créerModules
/* Constructeur */
public Base () {
définirEnseignements();
définirUnitésCours();
} // Constructeur
public Professeur getProf (String prof) {return (Professeur)professeurs.get(prof.toUpperCase());}
public Module getMod (int mod) {return (Module)modules.get(new Integer(mod));}
public UnitéCours getUC (String uc) {return (UnitéCours)unitésCours.get(uc.toUpperCase());}
"Modélisation"));
"Base de données"));
"Théorie et élaboration des SI"));
"Construction des SI"));
"Fondements de la programmation"));
"Programmation modulaire"));
"Algorithmes et structures de données"));
"Programmation orientée objet"));
/* Liste d'unités de cours */
private HashMap unitésCours = créerUnitésCours() ;
private HashMap créerUnitésCours () {
HashMap uc = new HashMap();
uc.put("MOD1",
new UnitéCours("Modélisation 1"));
new UnitéCours("Base de données 1"));
uc.put("BDD1",
uc.put("BDD2",
new UnitéCours("Base de données 2"));
uc.put("MOD2",
new UnitéCours("Modélisation 2"));
uc.put("BDD3",
new UnitéCours("Base de données 3"));
uc.put("GL1",
new UnitéCours("Génie Logiciel 1"));
uc.put("METH1", new UnitéCours("Méthodes et conception 1"));
uc.put("MODSI1", new UnitéCours("Modélisation des SI 1"));
uc.put("BDD4",
new UnitéCours("Base de données 4"));
uc.put("GL2",
new UnitéCours("Génie Logiciel 2"));
uc.put("METH2", new UnitéCours("Méthodes et conception 2"));
uc.put("MODSI2", new UnitéCours("Modélisation des SI 2"));
uc.put("ALGO1", new UnitéCours("Algorithmes 1"));
uc.put("PROG1", new UnitéCours("Programmation 1"));
uc.put("ALGO2", new UnitéCours("Algorithmes 2"));
uc.put("PROG2", new UnitéCours("Programmation 2"));
uc.put("ALGO3", new UnitéCours("Algorithmes 3"));
uc.put("PROG3", new UnitéCours("Programmation 3"));
uc.put("ALGO4", new UnitéCours("Algorithmes 4"));
uc.put("PROG4", new UnitéCours("Programmation 4"));
return uc;
} // créerUnitésCours
private void defUC (int numMod, String[] uc) {
Module m = getMod(numMod);
for (int i = 0; i < uc.length; i++) {
UnitéCours u = getUC(uc[i]);
m.addUnité(u); u.setModule(m);
}
} // defUC
private void définirUnitésCours () {
defUC(611, new String[]{"MOD1", "BDD1"});
defUC(612, new String[]{"MOD2", "BDD2"});
defUC(613, new String[]{"BDD3", "GL1", "METH1", "MODSI1"});
defUC(614, new String[]{"BDD4", "GL2", "METH2", "MODSI2"});
defUC(621, new String[]{"ALGO1", "PROG1"});
defUC(622, new String[]{"ALGO2", "PROG2"});
defUC(623, new String[]{"ALGO3", "PROG3"});
defUC(624, new String[]{"ALGO4", "PROG4"});
} // définirUnitésCours
private void defEns (int numMod, String[] profs) {
Module m = getMod(numMod);
for (int i = 0; i < profs.length; i++) {
public String toString () {
String s = "";
s = s + "Liste des professeurs:\n";
Iterator it = professeurs.values().iterator();
while (it.hasNext()) s = s + it.next() + "\n";
s = s + "\n\n";
for (int i = 611; i <= 614; i++) s = s + getMod(i);
for (int i = 621; i <= 624; i++) s = s + getMod(i);
return s;
} // toString
/* Affichage de l'état actuel du jeu de test */
public static void main (String[] args) {System.out.println(new Base());}
} // Base
/*611*/
/*612*/
/*613*/
/*614*/
/*621*/
/*623*/
/*623*/
/*624*/
/**
* Module.
*
* @author Peter DAEHNE
* @version 1.0
*/
import java.util.*;
public class Module {
private int numéro;
private String titre;
private HashSet professeurs = new HashSet(); /* Les professeurs enseignant dans ce module */
public HashSet getProfesseurs () {return professeurs;}
public void addProfesseur (Professeur prof) {professeurs.add(prof);}
public void removeProfesseur (Professeur prof) {professeurs.remove(prof);}
private HashSet unités = new HashSet(); /* Les unités de cours de ce module */
public HashSet getUnités () {return unités;}
public void addUnité (UnitéCours uc) {unités.add(uc);}
public void removeUnité (UnitéCours uc) {unités.remove(uc);}
public Module (int numéro, String titre) {
this.numéro = numéro;
this.titre = titre;
} // Constructeur
public String toString () {
String s = "Module n°" + numéro + " - " + titre + "\n professeurs: ";
Iterator it = professeurs.iterator();
while (it.hasNext()) s = s + it.next() + ", ";
s = s.substring(0, s.length()-2) + "\n unités de cours: ";
it = unités.iterator();
while (it.hasNext()) s = s + it.next() + ", ";
s = s.substring(0, s.length()-2) + "\n\n";
return s;
} // toString
} // Module
/**
* UnitéCours.
*
* @author Peter DAEHNE
* @version 1.0
*/
import java.util.*;
public class UnitéCours {
private String nom;
private Professeur responsable;
public Professeur getResponsable () {return responsable;}
public void setResponsable (Professeur prof) {
responsable = prof;
String msg = "Le responsable du cours doit faire partie des professeurs enseignant dans le module (inv)" ;
assert invResponsable() : msg; /* Invariant */
} // setResponsable
private Module module;
public Module getModule () {return module;}
public void setModule (Module module) {this.module = module;}
public UnitéCours (String nom) {
this.nom = nom;
} // Constructeur
public String toString () {return nom;}
/* Invariant */
public boolean invResponsable () {return module.getProfesseurs().contains(responsable);}
} // UnitéCours
/**
* Professeur.
*
* @author Peter DAEHNE
* @version 1.0
*/
import java.util.*;
public class Professeur {
private String nom, prénom;
private HashSet enseignements = new HashSet(); /* Les enseignements du professeur */
public HashSet getEnseignements () {return enseignements;}
public void addEnseignement (Module module) {enseignements.add(module);}
public void removeEnseignement (Module module) {enseignements.remove(module);}
private HashSet cours = new HashSet(); /* Les unités de cours du professeur */
public HashSet getCours () {return cours;}
public Professeur (String nom, String prénom) {
this.nom = nom;
this.prénom = prénom;
} // Constructeur
public void attribue (UnitéCours uc) {
String msg1 = "L'unité de cours doit faire partie des modules enseignés (pré)";
String msg2 = "L'unité de cours a déjà été attribuée à ce professeur (pré)";
String msg3 = "L'unité de cours n'a pas été attribuée à ce professeur (post)";
assert enseignements.contains(uc.getModule()) : msg1; /* Précondition 1 */
assert !cours.contains(uc) : msg2; /* Précondition 2 */
cours.add(uc);
assert cours.contains(uc) : msg3; /* Postcondition */
} // attribue
public String toString () {return prénom + " " + nom;}
} // Professeur
/**
* Enseignements - Test des contraintes.
*
* @author Peter DAEHNE
* @version 1.1
*/
import junit.framework.*;
public class TestContraintes extends TestCase {
private Base base; /* Base de test */
/* Fixture: création des données de test */
protected void setUp () {
base = new Base();
} // setUp
/* Violation de l'invariant: le responsable du cours doit enseigner dans le module */
public void testInvResponsable () {
try {
base.getUC("BDD1").setResponsable(base.getProf("PD"));
}
catch (AssertionError e) {return;}
fail("On peut définir un responsable du cours qui ne fait partie des professeurs enseignant dans le module" );
} // testInvResponsable
/* Violation de la précondition: l'unité de cours doit faire partie des modules enseignés par le prof */
public void testPreAttribueUC1 () {
try {
base.getProf("PD").attribue(base.getUC("BDD1"));
}
catch (AssertionError e) {return;}
fail("On peut attribuer une unité de cours ne faisant pas partie des modules enseignés par le prof" );
} // testPreAttribueUC1
/* Violation de la précondition: l'unité de cours ne doit pas déjà être attribuée au prof */
public void testPreAttribueUC2 () {
base.getProf("PD").attribue(base.getUC("ALGO3"));
try {
base.getProf("PD").attribue(base.getUC("ALGO3"));
}
catch (AssertionError e) {return;}
fail("On peut attribuer une unité de cours qui est déjà attribuée au prof");
} // testPreAttribueUC2
public static void main (String[] args) {
junit.textui.TestRunner.run(new TestSuite(TestContraintes.class));
} // main
} // TestContraintes
/**
* Enseignements - Test de la fonctionnalité.
*
* @author Peter DAEHNE
* @version 1.0
*/
import junit.framework.*;
public class TestFonctionnalité extends TestCase {
private Base base; /* Base de test */
/* Fixture: création des données de test */
protected void setUp () {
base = new Base();
} // setUp
/* Cas standard */
public void testCasStandard () {
Professeur prof; UnitéCours uc;
prof = base.getProf("PD");
uc = base.getUC("ALGO3");
prof.attribue(uc);
assertTrue(prof.getCours().contains(uc)); /* L'uc doit maintenant faire partie des cours du prof */
uc.setResponsable(prof);
assertTrue(uc.getResponsable().equals(prof)); /* Le responsable doit maintenant être le prof */
uc = base.getUC("ALGO4");
prof.attribue(uc);
assertTrue(prof.getCours().contains(uc)); /* L'uc doit maintenant faire partie des cours du prof */
uc.setResponsable(prof);
assertTrue(uc.getResponsable().equals(prof)); /* Le responsable doit maintenant être le prof */
} // testCasStandard
public static void main (String[] args) {
junit.textui.TestRunner.run(new TestSuite(TestFonctionnalité.class));
} // main
} // TestFonctionnalité