Examen GL1
Examen GL1
Programming and Software Engineering · exam
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
L'objectif principal des tests de programmes est de détecter le maximum d'erreurs (ou "bugs") avant la mise en production du logiciel, afin de garantir qu'il répond correctement aux exigences fonctionnelles et non-fonctionnelles définies dans le cahier des charges. Tester permet de vérifier la fiabilité, la sécurité et les performances de l'application.
Il est théoriquement impossible de prouver l'absence totale d'erreurs (sauf pour des programmes triviaux). L'arrêt des tests est donc une décision pragmatique basée sur des critères prédéfinis :
Un module logiciel est un composant logique et indépendant d'un programme, qui regroupe un ensemble de données et d'instructions visant à accomplir une tâche spécifique. Il possède une interface bien définie qui lui permet de communiquer avec d'autres modules tout en masquant les détails de son implémentation interne (encapsulation).
L'objectif de la décomposition modulaire est de maîtriser la complexité d'un grand système logiciel en le divisant en sous-systèmes plus petits et gérables (principe de "diviser pour régner"). Cela permet :
Les critères fondamentaux à respecter dans la décomposition modulaire sont :
Décision de l'arrêt de la décomposition : On arrête de décomposer lorsqu'un module atteint un niveau où il réalise une tâche conceptuelle unique et atomique, et que sa complexité est facilement compréhensible par un seul développeur. Poursuivre la décomposition au-delà de ce point réduirait la cohésion et augmenterait inutilement le couplage et le nombre d'interfaces à gérer.
Choix et combinaison : On choisit le MVC lorsqu'on développe une application nécessitant une interface utilisateur riche et interactive, pour séparer clairement l'affichage de la logique de contrôle. On choisit le 3-tiers lorsqu'on développe une application d'entreprise nécessitant de la sécurité, de la montée en charge (scalabilité) et le partage de données entre de multiples clients. Exemple : Les deux sont souvent utilisés ensemble. Une application de commerce en ligne peut utiliser une architecture 3-tiers où le serveur web (couche de présentation) utilise le patron MVC (comme Spring MVC ou Ruby on Rails) pour générer les pages web, qui communique ensuite avec un serveur d'application (logique métier) et un serveur de base de données (données).
Une méthode doit traiter une tâche unique liée à l'entité que représente la classe. Si une tâche concerne conceptuellement l'objet mais relève d'une responsabilité technique différente (comme le stockage, l'affichage réseau ou la sérialisation), elle ne doit pas se trouver dans la classe de l'entité.
Exemple : Prenons une classe Etudiant avec les attributs nom et matricule. La méthode pour sauvegarder cet étudiant dans une base de données relationnelle (sauvegarderEnBase()) concerne directement l'étudiant, mais elle implique de la logique SQL et de connexion réseau. Pour respecter la cohésion, on ne la met pas dans la classe Etudiant (qui ne doit gérer que la logique métier de l'étudiant). On crée une classe séparée dédiée à la persistance, par exemple EtudiantDAO (Data Access Object), qui contiendra la méthode sauvegarder(Etudiant e).
Puisqu'il n'est pas possible de dessiner graphiquement ici, voici la spécification textuelle exacte du diagramme de contexte selon le formalisme des Diagrammes de Flots de Données (DFD).
Pour raffiner le processus, nous zoomons sur le système pour faire apparaître la gestion des réservations, les autres processus internes et les stockages de données (Bases de données / Fichiers).
Gestion des réservations : Données passager, choix du vol.Gestion des réservations -> Stockage D1 (Vols) : Requête de disponibilité.Gestion des réservations -> Calcul des prix : Demande de tarification avec date.Calcul des prix -> Gestion des réservations : Tarif calculé.Gestion des réservations -> Stockage D2 (Réservations) : Enregistrement des données.Gestion des réservations -> Utilisateur : Billet / État actualisé.Architecture proposée : Architecture 3-tiers (Client-Serveur à 3 niveaux).
Justification des choix : Le cahier des charges précise que l'application est utilisée à la fois en agence et via Internet, et par des utilisateurs différents (Clients, Gérants) effectuant des opérations concurrentes (réserver, annuler, modifier les prix).
La classe Java Anonyme présente de graves défauts de conception :
ConnexionBD et arrêt).authentification avec login/psw).AjouterPersonne et SupprimerPersonne avec id/Nom).java.sql.*). Les requêtes SQL (chaînes de caractères en dur) sont mélangées aux méthodes métier, rendant tout changement de base de données ou de structure de table très difficile.connexion, instruction, résultat) sont partagées globalement par toutes les méthodes, créant des effets de bord imprévisibles (si deux méthodes sont appelées successivement, l'état de instruction est écrasé).Public, Return, Import), des erreurs de conception (instancier des variables de connexion en public), et une erreur de type critique (importation de java.beans.Statement au lieu de java.sql.Statement, ce qui obligeait le développeur à faire des "casts" hasardeux : (java.sql.Statement) instruction).Pour résoudre ces problèmes, nous devons décomposer ce code en appliquant le principe de responsabilité unique (SRP) de l'architecture MVC ou 3-tiers :
Personne, Utilisateur).Voici le code corrigé, structuré et fonctionnel :
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
// 1. Classe de gestion de la connexion (Singleton ou Utilitaire)
class DBManager {
public static Connection getConnection() throws SQLException {
try {
Class.forName("com.mysql.jdbc.Driver");
return DriverManager.getConnection("jdbc:mysql://localhost:3306/Projet", "root", "admin");
} catch (ClassNotFoundException ex) {
throw new SQLException("Problème de pilote de base de données");
}
}
}
// 2. Modèles de données (Entités de base)
class Personne {
private int id;
private String nom;
public Personne(int id, String nom) {
this.id = id;
this.nom = nom;
}
public int getId() { return id; }
public String getNom() { return nom; }
}
// 3. Classes d'accès aux données (DAO) - Haute cohésion, gère uniquement le SQL
class PersonneDAO {
// Utilisation de PreparedStatement pour corriger les failles d'injection SQL du code original
public void ajouterPersonne(Personne p) {
String sql = "INSERT INTO Personnels (matricule, nom) VALUES (?, ?)";
try (Connection conn = DBManager.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, p.getId());
pstmt.setString(2, p.getNom());
pstmt.executeUpdate();
} catch (SQLException ex) {
System.err.println("Erreur lors de l'ajout: " + ex.getMessage());
}
}
public void supprimerPersonne(int id) {
String sql = "DELETE FROM Personnels WHERE matricule = ?";
try (Connection conn = DBManager.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, id);
pstmt.executeUpdate();
} catch (SQLException ex) {
System.err.println("Erreur lors de la suppression: " + ex.getMessage());
}
}
}
class AuthentificationDAO {
public boolean authentifier(String login, String psw) {
String sql = "SELECT psw FROM Identification WHERE login = ?";
try (Connection conn = DBManager.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, login);
try (ResultSet rs = pstmt.executeQuery()) {
if (rs.next()) {
String motDePasseBase = rs.getString(1);
return motDePasseBase.equals(psw);
}
}
} catch (SQLException ex) {
System.err.println("Erreur d'authentification: " + ex.getMessage());
}
return false;
}
}
Le code source a été décomposé en nœuds (blocs de base) pour établir le graphe de flux de contrôle (Control Flow Graph). Voici la numérotation logique des instructions :
int m; int g = 0; int d = tab_trie.length-1; boolean trouv = false; (Ligne 8)while (g <= d && !trouv) (Ligne 9)m = (d+g)/2; (Ligne 11)if (tab_trie[m] == cle) (Ligne 12)trouv = true; (Ligne 13)else if (tab_trie[m] > cle) (Ligne 14)d = m-1; (Ligne 15)g = m+1; (Ligne 17)return trouv; (Ligne 19)(Note : Dans de nombreuses conventions, la fin du bloc conditionnel rejoint l'évaluation de la boucle, créant des arcs vers le Nœud 2).
Arcs (Transitions du graphe) :
Pour couvrir toutes les instructions, chaque nœud de 1 à 9 doit être visité au moins une fois. Nous devons trouver la clé au milieu (Nœud 5), chercher à gauche (Nœud 7) et chercher à droite (Nœud 8). Un seul tableau avec deux appels de tests différents suffit :
tab_trie = {10, 20, 30}cle = 10
m = 1, tab_trie[1] est 20. 20 > 10, exécute d = 0 (Couvre le Nœud 7).m = 0, tab_trie[0] est 10. 10 == 10, exécute trouv = true (Couvre le Nœud 5).cle = 30
m = 1, tab_trie[1] est 20. 20 n'est pas > 30, exécute g = 2 (Couvre le Nœud 8).L'ensemble des tests (A et B) garantit que les instructions 1, 2, 3, 4, 5, 6, 7, 8 et 9 sont exécutées au moins une fois.
Analyse des arcs couverts par les tests A et B :
Les tests A et B sortent de la boucle car la variable trouv passe à true (l'évaluation !trouv de la boucle while devient fausse).
L'arc (2) -> (9) représentant la sortie de boucle est donc visité suite à la falsification de !trouv.
Cependant, l'arc où la boucle s'arrête parce que le tableau entier a été parcouru sans succès (c'est-à-dire quand la condition g <= d devient fausse) n'est pas strictement validé s'il on considère les conditions multiples. De plus, il est de bonne pratique de tester le chemin où l'élément est absent pour s'assurer de parcourir l'arc (2) -> (9) par épuisement des index.
Nouvelle donnée de test à ajouter :
tab_trie = {10, 20, 30}, cle = 50.
g devienne strictement supérieur à d, forçant la condition g <= d à s'évaluer à faux.
Avec les tests A, B et C, 100% des arcs (branches vraies et fausses de chaque condition, y compris la condition de sortie de boucle par non-trouvaille) sont couverts.Pour valider le fonctionnement de la boucle while, il faut tester ses limites d'itération :
g <= d soit fausse dès l'initialisation. Cela se produit avec un tableau vide.
tab_trie = {} (tableau vide), cle = 5.g = 0, d = -1. 0 <= -1 est faux, la boucle ne s'exécute pas.tab_trie = {10, 20, 30}, cle = 20.m = 1, tab_trie[1] == 20. trouv = true, la boucle s'arrête à l'évaluation suivante.tab_trie = {10, 20, 30}, cle = 10.d, le second passage trouve la clé.Face à ce type de sujet de Génie Logiciel, la démarche est la suivante :
if, les while) et les blocs d'instructions. Pour trouver les données de test, simulez l'exécution pas à pas (trace manuelle) avec des valeurs simples et de petits tableaux jusqu'à passer par tous les embranchements de votre graphe. Pensez toujours aux cas limites (tableau vide, élément non trouvé).