Cours Génie logiciel

Planches de TD :
- TD 1 (pdf)
- TD 2 (pdf)
- TD 3 (pdf)
- TD 4 (pdf)
- TD 5 (pdf)
- TD 6 (pdf)
- TD 7 (pdf)
Planches de TP :
- TP 1 (pdf)
- TP 2 (pdf)
- TP 3 (pdf)
Polycopiés de cours :
- Introduction (pdf)
- Gestion de versions (pdf)
- Tests (pdf)
- Documentation (pdf)
- UML (pdf)
- Principes SOLID (pdf)
- Patrons de conception (pdf)
Annales :
- Sujet blanc, Corrigé
- Examen 2024-2025 (session 1), Corrigé

Gestion de notes

Introduction

Le but de ce TP est de concevoir une architecture logicielle permettant de gérer les règles d’attribution du diplôme de licence à l’université d’Aix-Marseille définie par les Modalités de Contrôle des Connaissances et des Compétences (M3C) en licence. Le but du logiciel sera de permettre le stockage des notes ainsi que la décision de validation ou non des différents éléments de la licence par les étudiants.

L’objectif pédagogique du projet est de vous faire travailler sur les outils et les bonnes pratiques pour le développement logiciel :

la gestion de version avec git ;
l’utilisation d’un moteur de production : gradle ;
l’utilisation de tests et la séparation code de production et test.

Logiciels

Si vous effectuez ce TP depuis votre machine personnelle, il vous faut installer les outils suivants :

Terminal shell si vous êtes sous windows, nous vous conseillons d’installer ubuntu sur windows pour avoir accès à un terminal shell. Sous MacOS etlinux, un terminal shell est disponible de base. On vous conseille d’installer Oh-my-zsh pour votre terminal qui rend l’utilisation de git dans le terminal plus convivial.
JDK version 21 ou plus la méthode d’installation dépend de votre système d’exploitation :
- Windows: Télécharger et exécuter l’Installeur windows
- MacOS: Télécharger et exécuter l’Installeur MacOS (attention à prendre le bon installeur suivant le processeur de votre ordinateur aarch64 pour les processeurs M1, M2, M3 ou M4 et x64 pour les processeurs intel)
- Linux: exécuter la commande suivante dans le terminal sudo apt install openjdk-21-jdk. Un mot de passe administrateur vous sera demandé.
gradle: Suivez les instructions au lien suivant : install gradle
git: Télécharger et installer git au lien suivant : download git
IntelliJ IDEA : vous pouvez télécharger IntelliJ IDEA ou bien JetBrains Toolbox qui est un outil pour gérer les IDE proposé par l’entreprise JetBrains. En tant qu’étudiant, vous avez d’ailleurs accès à des licences gratuites pour leurs produits et notamment la version ultimate d’IntelliJ IDEA en créant un compte avec votre adresse AMU via un formulaire. Vous pouvez aussi utiliser Eclipse ou Visual studio code qui sont des outils similaires.

Création de projet

Le but de la première partie de ce TP est d’apprendre à configurer un projet en utilisant IntelliJ IDEA ou bien entièrement en ligne de commande. Le projet permettra d’avoir de :

la gestion de version via git avec la création de branches ;
les tests unitaires avec Junit et AssertJ ;
un moteur de production gradle afin de gérer des dépendances et d’exécuter les tests unitaires ou des outils de mesure de la qualité du code.

On vous conseille aussi d’utiliser un IDE moderne pour le développement et non pas un simple éditeur de texte. Les instructions qui suivent décrivent l’utilisation d’IntelliJ IDEA mais vous pouvez utiliser d’autres IDE tels que Eclipse ou Visual studio code du moment que vous savez l’utiliser.

La création de projet se fera en plusieurs étapes :

La configuration d’une clé ssh pour se connecter au gitlab d’AMU appelé etulab.
La création de dépôts pour le projet : un sur le serveur d’etulab et un local sur lequel vous aller travailler (soit sur votre machine personnelle ou bien votre compte personnel AMU). Pour créer les deux dépôts, on vous propose soit d’utiliser l’IDE IntelliJ IDEA ou bien le terminal en ligne de commande.

Configuration clé ssh pour le gitlab AMU

Tâche 1 : créez puis utilisez une clé ssh en suivant les instructions qui suivent.

La première étape pour utiliser la gestion de version est de vous connecter au gitlab de l’université qui est accessible à l’adresse suivante : https://etulab.univ-amu.fr/. L’identifiant et le mot de passe sont ceux de votre compte étudiant AMU.

Afin de pouvoir accéder à distance à vos dépôts git, vous allez configurer une clé SSH dans votre profil. Pour cela, il vous faut :

Ouvrir un terminal (par exemple terminal MATE de la vdi Lunix qui est accessible dans le menu au sous-menu Outils systèmes). Si vous êtes sous windows et que vous avez installé Git pour windows, il est conseillé d’utiliser le terminal bash de git.
Générer une paire de clés privés/publiques pour votre compte. Pour cela, il vous faut entrer la commande suivante dans le terminal :
```
ssh-keygen -t ed25519
```
Appuyer une fois sur Entrée pour confirmer que vous voulez sauvegarder vos clés dans le répertoire par défaut.

Ensuite, il vous est demandé de rentrer deux fois une “passphrase”. Vous pouvez entrer une phrase (plusieurs mots donc) qui servira de mot de passe pour l’accès. Puisque la sécurité de vos dépôts n’est pas critique, vous pouvez vous contenter de ne rien rentrer (pas de passphrase) et donc d’appuyer de nouveau sur Entrée deux fois.

Si tout s’est bien passé, votre couple de clés a été généré et vous devriez voir un affichage similaire à celui ci-dessous :

Afficher votre clé dans le terminal en entrant la commande suivante (sous powershell, il faut remplacer la commande cat par la commande type) :
```
 cat ~/.ssh/id_ed25519.pub
```
Sélectionner la ligne affichée par le terminal et copier là dans le presse-papier (sélection puis clic droit et copier)
Configurer la clé dans votre compte gitlab. Pour cela, vous allez accéder aux préférences de votre compte gitlab. Il vous faut vous connecter à https://etulab.univ-amu.fr/ puis cliquez sur votre avatar en haut à gauche de l’écran puis sur preferences dans le menu qui apparaît.
Allez au menu des clés SSH en cliquant sur le lien correspondant dans le menu de gauche.

gitlab-ssh-key

Cliquez sur le bouton add new key

gitlab-ssh-key

Revenez sur la page de configuration des clés ssh sur votre navigateur. Coller votre clé (clic droit puis coller) dans l’espace prévu pour cela.

terminal-ssh-key

Ajouter la clé en cliquant sur le bouton add.

terminal-ssh-key

Vous devriez recevoir un mail sur votre mail étudiant confirmant que vous avez rajouté une clé. Vous pouvez rajouter autant de clés que vous voulez. Vous pouvez donc faire de même pour rajouter par exemple des clés supplémentaires si vous souhaitez accéder à votre dépôt depuis chez vous.

Tâche 2 : créez votre projet en suivant soit les instructions pour le faire avec IntelliJ IDEA ou bien en ligne de commandes.

Création de projet à l’aide d’IntelliJ

Création du dépôt local

Lancez IntelliJ IDEA
Accédez au menu en cliquant sur l’icône en haut à gauche de la fenêtre :

Commencez la création d’un nouveau projet via le menu file -> New -> Project :

Créer un projet pour le TP. Pour ce faire, il vous faut (dans l’ordre du haut vers le bas) :

Sélectionner dans la colonne de gauche Java comme type de projet
choisir un nom (name) pour votre projet, pour ce projet, le nom sera grades ;
choisir le répertoire de stockage (Location) du projet (vous pouvez laisser le répertoire de base qui est ~/IdeaProjects/)
cocher la case Create Git repository pour créer un dépôt git local ;
choisir un JDK de version 21 ou plus (normalement JDK 24 sur les ordinateurs de l’université) : vous pouvez demander le téléchargement d’un JDK ;
choisir gradle comme moteur de production (Build system) ;
choisir Kotlin comme Gradle DSL ;
ouvrir les paramètres avancés (Advanced Settings) ;
- choisir un identifiant de groupe¹ (GroupId) pour votre projet, pour ce projet, vous devez mettre fr.univ_amu.l3info ;
- choisir un identifiant de composant² (ArtifactId) pour votre projet, vous pouvez laisser le nom du projet (grades).
cliquez sur le bouton Create.
Si vous avez déjà un projet ouvert, une fenêtre s’ouvre pour vous demander si vous souhaitez ouvrir le projet dans une nouvelle fenêtre ou non. On vous conseille d’ouvrir le projet dans la fenêtre courante en cliquant sur le bouton This window

Votre projet devrait s’ouvrir et vous devriez obtenir l’affichage suivant :

Laisser le temps à votre projet de se configurer la barre en bas devrez indiquer que l’import est en cours :

Une fois l’import gradle fini, vous pouvez ouvrir le menu gradle en cliquant sur l’icône éléphant à droite. Vous avez éventuellement besoin de cliquer sur l’icône avec deux flèches en haut à gauche de l’onglet gradle pour faire apparaitre la liste des tâches gradle.

Explication fichiers et répertoires du projet

Votre projet devrait avoir l’arborescence de fichiers suivante :

Le répertoire .gradle contient les fichiers de configuration de gradle.
Le répertoire .idea contient les fichiers de configuration d’IntelliJ Idea.
Le répertoire gradle contient le gradle wrapper qui permet de fixer la version de gradle. Les fichiers indispensables sont :
- gradle-wrapper.properties qui configure entre autre la version de gradle téléchargée.
- gradle-wrapper.jar qui est un fichier essentiel pour l’exécution du wrapper.
Le répertoire src contient le code du projet.
- Le sous-répertoire main contient les fichiers pour le code principal de l’application, c’est-à-dire les fichiers nécessaires pour le lancement de l’application. Le sous-répertoire java contient les fichiers Java alors que le sous-répertoire ressources contient les autres types de fichiers comme des fichiers de configuration ou des images pour l’interface graphique.
- Le sous-répertoire test contient les fichiers pour le code de test. Le sous-répertoire java contient les fichiers Java alors que le sous-répertoire ressources contient les autres types de fichiers comme des fichiers d’entrée pour des tests de lecture.
Le fichier .gitignore liste les fichiers à ignorer lors des commit de git.
Le fichier build.gradle.kts est un fichier de configuration gradle définissant en autre les dépendances du projet.
Les fichiers gradlew et gradle.bat sont les fichiers de script pour le wrapper gradle respectivement pour les systèmes Unix et Windows.
Le fichier settings.gradle.kts est un fichier de configuration de gradle permettant en autre de définir le nom du projet.

Création du dépôt distant et du lien entre les deux dépôts

Connectez-vous via à un navigateur à votre compte etulab.
Commencez la création d’un nouveau projet en cliquant sur menu puis Create new project.

Choisissez Create blank project.

Remplissez le formulaire de la façon suivante :
- Choisissez comme nom de projet (project name) Grades suivi par les noms complets (nom suivi du prénom) du ou des deux étudiants dans le projet ;
- Indiquez comme namespace le namespace correspondant à votre compte (numéro d’étudiant précédé de la première de votre nom) ;
- Vérifier que le project slug est grades suivi du nom du ou des étudiants du projet séparés par des tirets ;
- Décochez la création du README.md (case à côté de Initialize repository with a README) ;
- Validez la création en cliquant sur le bouton Create project.

Une fois votre projet créé, copiez l’adresse pour cloner votre projet en cliquant sur le bouton code puis sur l’icône de copie ssh.

Retournez sur votre projet sur IntelliJ et allez dans le menu : git puis Manage Remotes.
Cliquez sur le bouton + pour ajouter un dépôt distant à votre dépôt local.

Collez l’adresse de votre dépôt distant dans le champ URL et validez l’ajout en cliquant sur le bouton OK deux fois (une fois pour la fenêtre Define remote et une autre fois pour la fenêtre Git remotes).

Opérations de base de git sous IntelliJ IDEA

Une fois votre projet créé, vous avez à partir du menu dédié les trois opérations de base de git :

commit pour créer une mise à jour du code avec un message
update project pour mettre à jour la version locale du projet à partir de celle du serveur (récupère les commits du serveur)
push pour mettre à jour la version du serveur à partir de la version locale (pousse les commits sur la version du serveur)

Pour faire un commit, il vous suffit de :
- cocher les fichiers que vous voulez modifier (changes) ;
- de donner un message explicite des modifications faites dans le code (texte en bas) ;
- et finalement de valider en cliquant sur le bouton commit.

pour faire un update project, il vous suffit de :
- de choisir entre merge et rebase (généralement vous pouvez vous contenter du merge) :
  - Le merge préserve l’historique complet du développement en créant de nouveaux commits qui combinent les branches sans modifier les commits existants.
  - Le rebase réécrit l’histoire en rejouant les commits d’une branche sur une autre.
- de donner un message explicite des modifications faites dans le code (texte en bas) ;
- et finalement de valider en cliquant sur le bouton ok

pour faire un push, il vous suffit de :
- de vérifier que la liste à gauche contient bien tous les messages des commits que vous souhaitez pousser sur le serveur ;
- de vérifier que la liste à droite contient les fichiers modifiés par les commits
- et finalement de valider en cliquant sur le bouton push.

Création de projet versionné en ligne de commande

Si vous avez créé votre projet avec IntelliJ IDEA, vous pouvez ignorer cette partie qui décrit la création de projet utilisant uniquement le terminal shell et donc sans IntelliJ IDEA.

Création de projet versionné en ligne de commande

Si vous avez créé votre projet avec IntelliJ IDEA, vous pouvez ignorer cette partie qui décrit la création de projet utilisant uniquement le terminal shell et donc sans IntelliJ IDEA.

Création de projet gradle en ligne de commande

La première étape de la création du projet est de créer un projet gradle.

Créez le répertoire qui va contenir votre projet qui devra être nommé m3c.
Pour commencer la création de votre projet lancez la commande gradle init alors que vous êtes dans le répertoire m3c.
- On vous demande tout d’abord quel type de projet vous souhaitez créer. Tapez 1 puis entrée pour choisir application.
- On vous demande le langage de projet. Tapez 1 puis entrée pour choisir Java.
- On vous demande ensuite la version java du projet, vous pouvez laisser 21 qui est la version par défaut.
- On vous demande le nom de votre projet. Vous pouvez laisser le nom par défaut ou bien définir votre propre nom de projet.
- On vous demande si votre projet est une application simple ou application et library. Tapez 1 et validez avec la touche entrée pour choisir Single application project.
- On vous demande si vous préférez utiliser Groovy ou Kotlin pour le langage de script de build. Tapez 1 puis entrée pour choisir Kotlin.
- On vous demande quel framework de tests vous souhaitez utiliser. Tapez 4 puis entrée pour choisir Junit Jupiter.

Explication fichiers et répertoires du projet

Votre projet devrait avoir l’arborescence de fichiers suivante :

Le répertoire .gradle contient les fichiers de configuration de gradle.
Le répertoire .idea contient les fichiers de configuration d’IntelliJ Idea.
Le répertoire gradle contient le gradle wrapper qui permet de fixer la version de gradle. Les fichiers indispensables sont :
- gradle-wrapper.properties qui configure entre autre la version de gradle téléchargée.
- gradle-wrapper.jar qui est un fichier essentiel pour l’exécution du wrapper.
Le sous-répertoire src du répertoire app contient les fichiers sources du projet.
- Le sous-répertoire main contient les fichiers pour le code principal de l’application, c’est-à-dire les fichiers nécessaires pour le lancement de l’application. Le sous-répertoire java contient les fichiers Java alors que le sous-répertoire ressources contient les autres types de fichiers comme des fichiers de configuration ou des images pour l’interface graphique. Le fichier App.java contient la méthode main qui est exécuté lorsque vous taper la commande gradle run.
- Le sous-répertoire test contient les fichiers pour le code de test. Le sous-répertoire java contient les fichiers Java alors que le sous-répertoire ressources contient les autres types de fichiers comme des fichiers d’entrée pour des tests de lecture. Le fichier AppTest.java contient des tests qui sont exécutés lorsque vous taper la commande gradle test. Si les tests échouent la commande vous donne un lien à ouvrir avec un navigateur.
- Le fichier build.gradle.kts est un fichier de configuration gradle définissant en autre les dépendances du projet.
Les fichiers gradlew et gradle.bat sont les fichiers de script pour le wrapper gradle respectivement pour les systèmes Unix et Windows.
Le fichier settings.gradle.kts est un fichier de configuration de gradle permettant en autre de définir le nom du projet.

Création de dépôt `git`

Dans le répertoire contenant votre projet gradle, exécutez la commande git init --initial-branch=main pour créer un dépôt git local.
Dans le répertoire contenant votre projet gradle, exécutez la commande git add non_de_fichier pour ajouter les fichiers de votre projet à votre prochain commit.
Il vous faudra ajouter tous les fichiers Java ainsi que les fichiers de configuration de gradle : build.gradle.kts, gradlew, gradlew.bat, settings.gradle.kts, gradle-wrapper.properties, gradle-wrapper.jar et libs.versions.toml.
Exécutez la commande git commit -m"premier message" pour faire un premier commit de votre projet avec votre propre message.

Création du dépôt distant et du lien entre les deux dépôts

Connectez-vous via à un navigateur à votre compte etulab.
Commencez la création d’un nouveau projet en cliquant sur menu puis Create new project.

Choisissez Create blank project.

Remplissez le formulaire de la façon suivante :
- Choisissez comme nom de projet (project name) Grades suivi par les noms complets (nom suivi du prénom) du ou des deux étudiants dans le projet ;
- Indiquez comme namespace le namespace correspondant à votre compte (numéro d’étudiant précédé de la première de votre nom) ;
- Vérifier que le project slug est grades suivi du nom du ou des étudiants du projet séparés par des tirets ;
- Décochez la création du README.md (case à côté de Initialize repository with a README) ;
- Validez la création en cliquant sur le bouton Create project.

Une fois votre projet créé, copiez l’adresse pour cloner votre projet en cliquant sur le bouton code puis sur l’icône de copie ssh.

Retournez sur votre projet sur IntelliJ et allez dans le menu : git puis Manage Remotes.
Cliquez sur le bouton + pour ajouter un dépôt distant à votre dépôt local.

Collez l’adresse de votre dépôt distant dans le champ URL et validez l’ajout en cliquant sur le bouton OK deux fois (une fois pour la fenêtre Define remote et une autre fois pour la fenêtre Git remotes).

Ajout des membres au projet

Pour ajouter un membre dans le projet, il faut aller sur votre projet sur etulab puis cliquer sur manage puis member et finalement cliquer sur le bouton invite members.

Pour ajouter un membre, il vous faut :
- chercher un compte via le nom d’utilisateur, le nom ou l’adresse mail ;
- choisir son rôle (reporter pour donner l’accès au code et owner pour donner les mêmes droits que le compte créateur du projet)
- donner une date (optionnel) de fin d’accès ;
- finalement cliquer sur bouton invite pour valider l’ajout du membre.

Tâche 3 : Ajouter comme membre au projet :

votre binôme (si vous faites le projet à deux) avec le rôle owner ;

l’enseignant Arnaud Labourel (login @alaboure et mail : arnaud.labourel@univ-amu.fr) avec le rôle reporter.

Méthodologie de travail

Tâche 4 : Configurer l’environnement pour les tests unitaires et l’exécution du code en suivant les instructions qui suivent.

Tests unitaires avec Junit 5

Pour ce TP, vous devez tester à l’aide de tests unitaires toutes les classes que vous écrirez. Normalement votre projet est déjà configuré pour le framework de test JUnit 5. On vous conseille d’utiliser AssertJ qui ajoute entre autre des assertions facilitant l’écriture des tests. Pour cela, il vous faut rajouter AssertJ dans les dépendances de gradle en rajoutant les lignes suivantes dans le fichier build.gradle.kts :

dependencies {
    testImplementation("org.assertj:assertj-core:3.26.3")
}

Une fois la ligne ajoutée au fichier, cliquez sur l’icône de mise à jour.

Pour pouvoir utiliser facilement les assertions (méthodes assertThat) dans vos classes de test, il vous faut ajouter l’import suivant dans chacune vos classes de tests :

import static org.assertj.core.api.Assertions.*;

Vous trouverez davantage de détails sur les tests unitaires dans le document dédié aux tests

Exécution du code

Afin de pouvoir tester votre code manuellement, on vous conseille d’utiliser gradle pour exécuter le code avec la tâche run ou bien construire un jar avec la tâche build.

Tâche `run`

Pour configurer la tâche run, on va commencer par rajouter (si besoin) le plugin application dans le fichier gradle.build.kts. Pour cela, on rajoute la ligne suivante :

plugins {
  id("application")
}

Comme indiqué précédemment, la tâche run vous permet d’exécuter la méthode main de la classe spécifiée dans le fichier gradle.build.kts. Cette classe correspond à la propriété mainClass du plugin application à l’aide des lignes suivantes :

application {
  mainClass = "fr.univ_amu.l3info.Main"
}

Vous pouvez ouvrir le menu gradle en cliquant sur l’icône éléphant à droite. Vous avez éventuellement besoin de cliquer sur l’icône avec deux flèches en haut à gauche de l’onglet gradle pour faire mettre à jour la liste des tâches gradle. La tâche run se trouve dans le répertoire application.

Run task

Tâche `build`

La tâche build définie par le plugin java permet de construire un jar dans le répertoire build/libs du projet. Afin que le jar fonctionne, il faut préciser la classe contenant le main à exécuter. Cela se fait par le biais du fichier manifest que l’on peut configurer en ajoutant les lignes suivantes dans le fichier gradle.build.kts.

tasks.withType<Jar> {
    manifest {
        attributes["Main-Class"] = "fr.univ_amu.l3info.Main"
    }
}

La tâche build se trouve dans le répertoire build. Une fois le jar créé vous pouvez l’exécuter avec la commande suivante :

java -jar nom-du-jar.jar

Tâches à réaliser

Architecture d’une licence

Chaque licence est organisée en trois années. Chaque année est composée de deux semestres. Chaque semestre est décomposé en trois ou quatre Blocs de Connaissances et de Compétences (BCC). Chaque BCC est composé d’une ou plusieurs UE. Les UE sont affectées d’un nombre défini de crédits (du système européen de transfert et d’accumulation de crédits).

Règles de calcul des moyennes

La moyenne d’un semestre est obtenue par calcul de la moyenne des BCC pondérée par les ECTS des UE qui les composent. Les crédits attribués à chaque UE sont utilisés comme coefficients pour le calcul des moyennes générales à l’année et au diplôme de licence.

Règles sur les BCC et les UE

Une UE est acquise par capitalisation dès lors que sa note est supérieure ou égale à 10/20. Les UE se compensent entre elles à l’intérieur d’un BCC. Une UE peut donc être acquise par compensation si elle n’est pas acquise par capitalisation et que le BCC qui la contient est acquis (par compensation ou capitalisation).

Règles de validation d’année

L’année est validée lorsque l’une des deux conditions suivantes est remplie :

Les moyennes annuelles des couples de BCC jumeaux sont supérieures ou égales à 10/20,
La moyenne annuelle d’un des couples de BCC jumeaux de l’année est inférieure à 10/20, mais supérieure ou égale à 9/20 et les moyennes annuelles des autres couples de BCC jumeaux sont supérieures ou égales à 10/20.

Un BCC peut donc être acquis par compensation si il n’est pas acquis par capitalisation et que l’année qui le contient est validée.

Règles sur les notes et les résultats

La note d’une UE est soit un nombre entre 0 et 20 avec une précision de 3 chiffres après la virgule (par exemple 13,203) ou bien une note correspondant à une absence. Toute moyenne avec au moins une note correspondant à une absence donne une note correspondant à une absence quel que soit le poids de la note dans le calcul. Le résultat d’un étudiant pour un élément de la formation (diplôme, année, semestre, BCC, UE) peut être :

Admis avec une des deux possibilités suivante :
- acquis par compensation
- acquis par capitalisation
Non-acquis avec deux possibilités :
- défaillant (note correspondant à une absence)
- ajourné (note inférieure à 10/20 et élément pas compensé)

La classe `Grade`

Spécification des classes `Grade`

La classe Grade permet de représenter des notes qui peuvent être un nombre entre 0 et 20 ou bien correspondre à une absence.

Tâches

Tâche 5 : Créez la classe Grade dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 6 : Créez une classe de test nommée GradeTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de la classe Grade. Vous devez tester les comportements suivants :

new Grade() construit une note correspondant à une absence ;

new Grade(20.0) construit une note correspondant à une valeur de 20 ;

new Grade().toString() retourne la chaîne de caractères ABS ;

new Grade(20.0).toString() retourne la chaîne de caractères 20,000/20 (vous pouvez pour cela utiliser la méthode format de String avec la chaîne de caractères %.3f pour obtenir une précision de trois chiffres après la virgule) ;

setAs(new Grade(10.0)) change la valeur de la note à 10 et la note ne correspond plus à une absence ;

setAs(new Grade()) change la note pour qu’elle corresponde à une absence.

La classe `WeightedGrade`

Spécification des classes `WeightedGrade`

La classe WeightedGrade permet de représenter des notes pondérées, c’est-à-dire une note (qui peut être un nombre entre 0 et 20 ou bien une absence) associée à un poids entier. Cette classe sera une extension de la classe Grade.

Voici le diagramme de cette classe :

Tâches

Tâche 7 : Créez la classe WeightedGrade dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 8 : Créez une classe de test nommée WeightedGradeTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de la classe WeightedGrade. Vous devez tester les comportements suivants :

new WeightedGrade(10) construit une note de poids 10 correspondant à une absence ;

new WeightedGrade(8, 20.0) construit une note de poids 8 correspondant à une valeur de 20 ;

new WeightedGrade(10).toString() retourne la chaîne de caractères ABS ;

new WeightedGrade(10, 20.0).toString() retourne la chaîne de caractères 20,000/20 ;

setAs(new Grade(10.0)) change la valeur de la note à 10 (sans changer son poids) et la note ne correspond plus à une absence ;

setAs(new Grade()) change la note pour qu’elle corresponde à une absence (sans changer son poids) ;

computeAverage(List.of(new WeightedGrade(1, 6.0), new WeightedGrade(2, 12.0))) retourne une note de poids 3 ayant une valeur de 10 et ne correspondant pas à une absence ;

computeAverage(List.of(new WeightedGrade(1, 6.0), new WeightedGrade(2))) retourne une note de poids 3 correspondant à une absence.

L’enum `Result`

Définir un enum Result permettant de représenter les 4 résultats possibles pour un élément de la formation (UE, BCC ou année) :

ACQUIRED_THROUGH_COMPENSATION : acquis par compensation
ACQUIRED_THROUGH_CAPITALIZATION : acquis par capitalisation
DEFAULTING : défaillant (au moins un élément avec une note correspondant à une absence)
FAILING : ajourné (note moyenne inférieure à 10/20 et élément pas compensé)

Tâches

Tâche 9 : Créez l’enum Result dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 10 : Créez une classe de test nommée ResultTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de l’enum Result. Vous devez tester les comportements suivants :

ACQUIRED_THROUGH_COMPENSATION.getCode() retourne la chaîne de caractères ACMP ;

ACQUIRED_THROUGH_CAPITALIZATION.getCode() retourne la chaîne de caractères ACAP ;

DEFAULTING.getCode() retourne la chaîne de caractères DEF ;

FAILING.getCode() retourne la chaîne de caractères AJ ;

ACQUIRED_THROUGH_COMPENSATION.isAcquired() retourne true ;

ACQUIRED_THROUGH_CAPITALIZATION.isAcquired() retourne true ;

DEFAULTING.isAcquired() retourne false ;

FAILING.isAcquired() retourne false ;

L’interface `TeachingElement`

L’interface TeachingElement est l’interface que devra implémenter tout élément de la formation (UE, BCC et Année)

Voici le diagramme de cette interface :

Tâches

Tâche 11 : Créez l’interface TeachingElement dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

La classe `TeachingUnit`

Spécification de la classe `TeachingUnit`

La classe TeachingUnit permet de représenter une Unité d’Enseignement (UE). Voici le diagramme de cette classe :

Tâches

Tâche 12 : Créez la classe TeachingUnit dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 13 : Créez une classe de test nommée TeachingUnitTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de la classe TeachingUnit. Vous devez tester les comportements suivants :

new TeachingUnit("Initiation Génie Logiciel", "SIN5U34", 3) une unité d’enseignement de nom Initiation Génie Logiciel de trois crédits ayant le code SIN5U34 associé à une note correspondant à une absence et sans parent (valeur null) ;

setGrade(new Grade(10.0)) fixe la note de l’unité d’enseignement à 10 ;

setGrade(new Grade()) fixe la note de l’unité d’enseignement à une absence ;

un appel à computeResult() sur une unité d’enseignement avec une note à 10/20 et sans parent retourne ACQUIRED_THROUGH_CAPITALIZATION ;

un appel à computeResult() sur une unité d’enseignement avec une note correspondant à une absence retourne DEFAULTING ;

un appel à computeResult() sur une unité d’enseignement avec une note à 5/20 et sans parent retourne FAILING ;

un appel à computeResult() sur une unité d’enseignement avec une note à 5/20 et avec parent correspondant à une UE ayant une note de 20/20 retourne ACQUIRED_THROUGH_COMPENSATION. > - un appel à computeResult() sur une unité d’enseignement avec une note à 5/20 et avec parent correspondant à une UE ayant une note de 5/20 retourne FAILING.

new TeachingUnit("Initiation Génie Logiciel", "SIN5U34").toString() sur lequel on a appelé setGrade(new Grade(10.)) devra renvoyer la chaîne de caractères Initiation Génie Logiciel, 3 crédits (SIN5U34) : 10,000/20 (ACAP) ;

un new TeachingUnit("Compilation", "SIN6U64", 3, 0.0).toString() sur lequel on a appelé setGrade(new Grade(0.)) devra renvoyer la chaîne de caractères Compilation, 3 crédits (SIN6U64) : 0,000/20 (AJ) ;

new TeachingUnit("Logique", "SIN5U25", 3).toString() devra renvoyer la chaîne de caractères Logique, 6 crédits (SIN5U25) : ABS (DEF).

L’interface `ResultCalculator` et les classes `AboveTenResultCalculator` et `YearResultCalculator`

Spécification des classes `BCCResultCalculator` et `YearResultCalculator`

Le but de cette partie est d’implémenter le calcul de règles de validation par des classes dédiées. Un calculateur de résultat aura une seule méthode qui prendra en paramètre les notes des éléments enfants (les UE pour les BCC et les BCC pour l’année). On considérera deux règles de calcul :

BCCResultCalculator : la méthode computeResult retourne
- DEFAULTING si au moins une note des enfants correspond à une absence ;
- ACQUIRED_THROUGH_CAPITALIZATION si la moyenne des notes des enfants est supérieure à 10 ;
- FAILING dans tous les autres cas.
YearResultCalculator : la méthode computeResult retourne
- DEFAULTING si au moins une note des enfants correspond à une absence ;
- ACQUIRED_THROUGH_CAPITALIZATION si :
  - toutes les notes des enfants sont supérieures ou égales à 9/20 et
  - au plus une seule note d’un des enfants est strictement inférieure à 10.
- FAILING dans tous les autres cas.

On va utiliser le diagramme de classes suivant :

Tâches

Tâche 14 : Créez l’interface ResultCalculator et les classes BCCResultCalculator et YearResultCalculator dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 15 : Créez les classes de test nommées BCCResultCalculatorTest et YearResultCalculatorTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires les comportements des classes BCCResultCalculator et YearResultCalculator.

Classe `CompositeTeachingElement`

L’idée de la classe CompositeTeachingElement est de permettre de factoriser le code commun entre un BBC qui contiendra des UE et une année qui contiendra des BCC. Fondamentalement, la seule véritable différence entre les deux classes sera la règle de calcul de résultat qui sera délégué à un objet implémentant l’interface ResultCalculator.

Le diagramme de classe est le suivant :

Tâches

Tâche 16 : Créez l’interface TeachingElementParent et la classe CompositeTeachingElement dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 17 : Créez une classe de test nommée CompositeTeachingElementTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de la classe CompositeTeachingElement. Vous devez tester les comportements suivants :

new CompositeTeachingElement("L3 DLMI", "SIN3I1", new YearResultCalculator()) crée un élément de nom L3 DLMI, avec un code SIN3I1 avec une règle de calcul d’année ;

new CompositeTeachingElement("BCC 1 (math)", "SINK10", new BCCResultCalculator()) crée un élément de nom BCC 1 (math), avec un code SINK10 avec une règle de calcul de BCC ;

p.addChild(c) ajoute un élément c comme enfant de l’élément composite p et fixe le parent de c à p ;

p.computeGrade() calcule la moyenne des éléments enfants de p ;

p.computeResult() applique la règle de validation calculée par un appel de resultCalculator sur les notes des enfants de p en ajoutant comme règle que si le parent de p est validé (résultat ACQUIRED_THROUGH_COMPENSATION ou ACQUIRED_THROUGH_CAPITALIZATION) et que le resultCalculator de p donne un résultat ajourné alors le résultat est ACQUIRED_THROUGH_COMPENSATION.

Classe `TeachingElementFactory`

L’idée de la classe TeachingElementFactory est de regrouper dans une seule classe les méthodes de création pour les éléments d’une formation :

createBCC permet de créer un BCC, c’est-à-dire un CompositeTeachingElement avec un BCCResultCalculator ;
createYear permet de créer une année, c’est-à-dire un CompositeTeachingElement avec un YearResultCalculator ;
createTeachingUnit crée une unité d’enseignement.

Le diagramme de classe est le suivant :

Tâche 18 : Créez la classe TeachingElementFactory dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Tâche 19 : Créez une classe de test nommée TeachingElementFactoryTest dans le répertoire src/test/java/fr/univ_amu/l3info de votre projet qui devra vérifier via des tests unitaires le comportement de la classe TeachingElementFactory.

Classe `YearManager`

L’idée de la classe YearManager est de permettre une gestion facile d’une année d’un diplôme. L’idée est de stocker les éléments (BCC et UE (TeachingUnit)) de la formation grâce à des Map avec comme clé les code des éléments. Le but de la classe est de stocker l’architecture de la formation et de permettre de calculer le résultat d’un étudiant à partir d’un Map qui associe chaque code d’UE à une note.

Tâche 20 : Créez la classe YearManager dans le répertoire src/main/java/fr/univ_amu/l3info de votre projet.

Classe `Main`

Tâche 21 : Utiliser le code suivant Main.java pour simuler les résultats d’une année de L3 double licence mathématiques-informatique, SIN3I1WL qui a la structure suivante :

BCC 1 : Maitriser les concepts fondamentaux des mathématiques, SINK10 :

Algèbre linéaire, SMI5U19 (6 crédits)

Suites et séries de fonctions, SMI5U21 (9 crédits)

Théorie des groupes, SMI3U20 (3 crédits)

Topologie, SMI6U29 (6 crédits)

Structures algébriques, SMI6U27 (6 crédits)

Sémantique, SIN6U65 (3 crédits)

BCC 2 : Mettre en œuvre des algorithmes, SINK11 :

Initiation génie logiciel, SIN5U31 (3 crédits)

Algorithmique 2, SIN5U24 (6 crédits)

Logique, SIN5U25 (6 crédits)

Calculabilité, SIN6U45 (3 crédits)

Compilation, SIN6U64 (3 crédits)

Développement durable, SIN6U66 (3 crédits)

BCC 3 : Valoriser et approfondir son parcours, SINK12

Introduction à l’apprentissage automatique, SIN6U54 (3 crédits)

Projet personnel et professionnel de l’étudiant 3, SIN5U29 (3 crédits)

Anglais 5, SIN5U30 (3 crédits)

Anglais 6, SIN5U61 (3 crédits)

Épreuve intégrative 3, SIN6U36 (3 crédits)

Épreuve intégrative 4, SIN6U73 (3 crédits)

Stage, SIN6U62 (6 crédits)

Vous devez obtenir l’affichage suivant :

L3 double licence mathématiques-informatique, 93 crédits (SIN3I1WL) : 10,806/20 (ACAP)
    BCC 2 : Mettre en œuvre des algorithmes, 27 crédits (SINK11) : 10,000/20 (ACAP)
        Initiation génie logiciel, 3 crédits (SIN5U31) : 10,000/20 (ACAP)
        Algorithmique 2, 6 crédits (SIN5U24) : 10,000/20 (ACAP)
        Logique, 6 crédits (SIN5U25) : 10,000/20 (ACAP)
        Calculabilité, 3 crédits (SIN6U45) : 10,000/20 (ACAP)
        Compilation, 3 crédits (SIN6U64) : 10,000/20 (ACAP)
        Développement durable, 6 crédits (SIN6U66) : 10,000/20 (ACAP)
    BCC 1 : Maitriser les concepts fondamentaux des mathématiques, 33 crédits (SINK10) : 12,818/20 (ACAP)
        Algèbre linéaire, 6 crédits (SMI5U19) : 15,000/20 (ACAP)
        Suites et séries de fonctions, 9 crédits (SMI5U21) : 14,000/20 (ACAP)
        Théorie des groupes, 3 crédits (SMI3U20) : 13,000/20 (ACAP)
        Topologie, 6 crédits (SMI6U29) : 12,000/20 (ACAP)
        Structures algébriques, 6 crédits (SMI6U27) : 11,000/20 (ACAP)
        Sémantique, 3 crédits (SIN6U65) : 10,000/20 (ACAP)
    BCC 3 : Valoriser et approfondir son parcours, 33 crédits (SINK12) : 9,455/20 (ACMP)
        Introduction à l'apprentissage automatique, 3 crédits (SIN6U54) : 9,000/20 (ACMP)
        Projet personnel et professionnel de l'étudiant 3, 6 crédits (SIN5U29) : 10,000/20 (ACAP)
        Anglais 5, 6 crédits (SIN5U30) : 10,000/20 (ACAP)
        Anglais 6, 6 crédits (SIN5U61) : 8,000/20 (ACMP)
        Épreuve intégrative 3, 3 crédits (SIN6U36) : 10,000/20 (ACAP)
        Épreuve intégrative 4, 3 crédits (SIN6U73) : 9,000/20 (ACMP)
        Stage, 6 crédits (SIN6U62) : 10,000/20 (ACAP)

L’identifiant de groupe (GroupId) permet de connaitre l’organisation, l’entreprise, l’entité ou la communauté qui gère le projet. Par convention, on utilise le nom de domaine Internet inversé, selon la même logique que celle généralement recommandée pour les noms de packages Java.↩︎
L’identifiant de composant (ArtifactId) est le nom unique du projet au sein du groupe qui le développe. Généralement, l’identifiant du composant est le nom du projet.↩︎

Gestion de notes

Introduction

Logiciels

Création de projet

Configuration clé ssh pour le gitlab AMU

Création de projet à l’aide d’IntelliJ

Création du dépôt local

Explication fichiers et répertoires du projet

Création du dépôt distant et du lien entre les deux dépôts

Opérations de base de git sous IntelliJ IDEA

Création de projet versionné en ligne de commande

Création de projet versionné en ligne de commande

Création de projet gradle en ligne de commande

Explication fichiers et répertoires du projet

Création de dépôt git

Création du dépôt distant et du lien entre les deux dépôts

Ajout des membres au projet

Méthodologie de travail

Tests unitaires avec Junit 5

Exécution du code

Tâche run

Tâche build

Tâches à réaliser

Architecture d’une licence

Règles de calcul des moyennes

Règles sur les BCC et les UE

Règles de validation d’année

Règles sur les notes et les résultats

La classe Grade

Spécification des classes Grade

Tâches

La classe WeightedGrade

Spécification des classes WeightedGrade

Tâches

L’enum Result

Tâches

L’interface TeachingElement

Tâches

La classe TeachingUnit

Spécification de la classe TeachingUnit

Tâches

L’interface ResultCalculator et les classes AboveTenResultCalculator et YearResultCalculator

Spécification des classes BCCResultCalculator et YearResultCalculator

Tâches

Classe CompositeTeachingElement

Tâches

Classe TeachingElementFactory

Classe YearManager

Classe Main

Création de dépôt `git`

Tâche `run`

Tâche `build`

La classe `Grade`

Spécification des classes `Grade`

La classe `WeightedGrade`

Spécification des classes `WeightedGrade`

L’enum `Result`

L’interface `TeachingElement`

La classe `TeachingUnit`

Spécification de la classe `TeachingUnit`

L’interface `ResultCalculator` et les classes `AboveTenResultCalculator` et `YearResultCalculator`

Spécification des classes `BCCResultCalculator` et `YearResultCalculator`

Classe `CompositeTeachingElement`

Classe `TeachingElementFactory`

Classe `YearManager`

Classe `Main`