Ce chapitre n’est pas accessible

Connectez-vous pour accéder à ce chapitre.

Se connecter Voir le programme

Sommaire

M1 Bienvenue et méthode de travail0/5
1. Bienvenue : ce que couvre ce parcours et comment il fonctionne— Chapitre en coursverrouillé
2. Apprendre seul : organiser ses sessions et la règle des 20 minutes— Non commencé
3. Ce que ce parcours couvre, et ce qu’il ne couvre pas— Non commencéverrouillé
4. Pré-requis : test de positionnement— Non commencéverrouillé
5. Le parcours module par module et la charge de travail réelle— Non commencéverrouillé
M2 Votre poste de travail0/4
M3 Culture QA : le métier, le vocabulaire, les repères0/12
1. Le métier d’automaticien de tests : missions et compétences— Non commencé
2. Le processus de test : les sept activités— Non commencéverrouillé
3. Choisir ce que l’on automatise : le processus et ses critères— Non commencéverrouillé
4. Exercice : quels cas de test automatiser ?— Non commencéverrouillé
5. Niveaux de test, environnements et types de test— Non commencéverrouillé
6. Exercice : remplir la matrice niveaux × types— Non commencéverrouillé
7. QM, QA, QC et Testing : qui fait quoi— Non commencéverrouillé
8. Full Stack QA : l’étendue du métier— Non commencéverrouillé
9. Ce qui change la QA : IA, tests continus, shift-left, cloud— Non commencéverrouillé
10. Métiers et trajectoires après le Niveau 1— Non commencéverrouillé
11. Les ressources de référence, et comment chercher seul— Non commencéverrouillé
12. Quiz de validation du module— Non commencéverrouillé
M4 Logique et algorithmique0/49
1. Pourquoi l’algorithmique quand on automatise des tests— Non commencéverrouillé
2. Comment un ordinateur traite et stocke l’information— Non commencéverrouillé
3. Le binaire, sans mathématiques— Non commencéverrouillé
4. Algorithme ou programme ? La recette et le plat— Non commencéverrouillé
5. Exercice : votre premier algorithme en langage naturel— Non commencéverrouillé
6. La carte de référence du pseudo-langage du cours— Non commencéverrouillé
7. Variables : type, nom, valeur— Non commencéverrouillé
8. Portée des variables : globale ou locale— Non commencéverrouillé
9. Opérateurs arithmétiques, et le piège du signe =— Non commencéverrouillé
10. Opérateurs logiques ET, OU, NON et tables de vérité— Non commencéverrouillé
11. Exercice : évaluer des expressions— Non commencéverrouillé
12. Quiz : bases, variables et opérateurs— À paraîtreà paraître
13. Les conditions : Si, Alors, Sinon— Non commencéverrouillé
14. Conditions imbriquées et ordre des tests— Non commencéverrouillé
15. Exercice : conditions et tranches tarifaires— Non commencéverrouillé
16. La boucle TantQue— Non commencéverrouillé
17. La boucle Pour— Non commencéverrouillé
18. Boucles imbriquées— Non commencéverrouillé
19. Méthode : tracer une exécution au tableau de trace— Non commencéverrouillé
20. Quiz : structures de contrôle— À paraîtreà paraître
21. Les tableaux : déclaration, indices, accès— Non commencéverrouillé
22. Modifier et parcourir un tableau— Non commencéverrouillé
23. Tableaux à deux dimensions— Non commencéverrouillé
24. Exercice : tableaux 1D et 2D— Non commencéverrouillé
25. TP guidé 1 : coût énergétique mensuel— Non commencéverrouillé
26. TP guidé 2 : coût énergétique annuel avec tableaux— Non commencéverrouillé
27. Les fonctions prédéfinies— Non commencéverrouillé
28. Fonction ou procédure ?— Non commencéverrouillé
29. Déclarer une fonction : signature, corps, retour— Non commencéverrouillé
30. Appeler une fonction : paramètre, argument, valeur ou référence— Non commencéverrouillé
31. Exercice : transformer un script linéaire en fonctions— Non commencéverrouillé
32. TP guidé 3 : gestion des notes d’étudiants— Non commencéverrouillé
33. La récursivité : cas de base et cas récursif— Non commencéverrouillé
34. Exercice : dérouler une récursion— Non commencéverrouillé
35. Quiz : fonctions et récursivité— À paraîtreà paraître
36. Compilation, interprétation, et le cas particulier de Java— Non commencéverrouillé
37. TP 4 : dérouler un programme à la main— Non commencéverrouillé
38. Factorisation : DRY, KISS, modularité— Non commencéverrouillé
39. TP 5 : factoriser le calcul de remise— Non commencéverrouillé
40. Clean code : nommer, découper, rendre testable— Non commencéverrouillé
41. Complexité temporelle et spatiale— Non commencéverrouillé
42. Types de langages : paradigmes, niveaux, usages et stack technique— Non commencéverrouillé
43. TP 6, partie 1 : températures, maximum et minimum— Non commencéverrouillé
44. TP 6, partie 2 : moyenne, médiane et affichage des statistiques— Non commencéverrouillé
45. TP 7, partie 1 : réservation de cinéma, la conception— Non commencéverrouillé
46. TP 7, partie 2 : réservation de cinéma, l’implémentation— Non commencéverrouillé
47. QCM final du module— À paraîtreà paraître
48. Fiche de révision algorithmique— Non commencéverrouillé
49. Passerelle : du pseudo-langage à Java— Non commencéverrouillé
M5 Java : les fondations0/37
1. Ce que vous saurez faire à la fin de ce module— À paraîtreà paraître
2. JVM, JRE, JDK : qui fait quoi— À paraîtreà paraître
3. Histoire de Java et raison du choix de Java 11— À paraîtreà paraître
4. Configurer VSCode pour Java— À paraîtreà paraître
5. Point de contrôle : l’installation— À paraîtreà paraître
6. BonjourMonde : votre premier programme— À paraîtreà paraître
7. Anatomie d’un fichier .java— À paraîtreà paraître
8. Quand ça ne compile pas : lire un message d’erreur— À paraîtreà paraître
9. Variables et types primitifs— À paraîtreà paraître
10. String et char : les pièges d’affichage— À paraîtreà paraître
11. Exercice guidé : déclarer, calculer, afficher— À paraîtreà paraître
12. Opérateurs arithmétiques et division entière— À paraîtreà paraître
13. Opérateurs de comparaison et opérateurs logiques— À paraîtreà paraître
14. Quiz : syntaxe de base— À paraîtreà paraître
15. Conditions : if, else, else if— À paraîtreà paraître
16. switch : quand le préférer à une cascade de if— À paraîtreà paraître
17. TP1 — Calcul du coût énergétique mensuel— À paraîtreà paraître
18. La boucle while— À paraîtreà paraître
19. La boucle for et la boucle for-each— À paraîtreà paraître
20. Boucles imbriquées sans se tromper— À paraîtreà paraître
21. Quiz : structures de contrôle— À paraîtreà paraître
22. Les tableaux à une dimension— À paraîtreà paraître
23. ArrayIndexOutOfBoundsException : l’erreur d’indice— À paraîtreà paraître
24. Les tableaux à deux dimensions— À paraîtreà paraître
25. TP2 — Facture annuelle avec tableaux— À paraîtreà paraître
26. Écrire une méthode : signature, paramètres, retour— À paraîtreà paraître
27. Appeler une méthode et suivre le passage par valeur— À paraîtreà paraître
28. static ou pas static : le piège numéro 1— À paraîtreà paraître
29. TP3 — Gestion des notes d’étudiants— À paraîtreà paraître
30. TP4 — Lire un programme et prévoir sa sortie— À paraîtreà paraître
31. TP5 — Factoriser un programme en méthodes— À paraîtreà paraître
32. TP6 — Statistiques de températures— À paraîtreà paraître
33. Déboguer pas à pas dans VSCode— À paraîtreà paraître
34. Conventions de nommage et lisibilité du code Java— À paraîtreà paraître
35. Les paradigmes de programmation— À paraîtreà paraître
36. Aide-mémoire Java : les fondations— À paraîtreà paraître
37. Évaluation finale du module— À paraîtreà paraître
M6 Programmation orientée objet0/37
1. Pourquoi la POO existe— À paraîtreà paraître
2. Glossaire POO : français, anglais, Java— À paraîtreà paraître
3. Quiz d’entrée : procédural ou objet ?— À paraîtreà paraître
4. L’environnement de travail : un fichier, une classe— À paraîtreà paraître
5. Écrire une première classe— À paraîtreà paraître
6. Créer des objets : new, référence, null— À paraîtreà paraître
7. Exercice : la classe Livre— À paraîtreà paraître
8. Visibilité : private, package-private, protected, public— À paraîtreà paraître
9. Getters et setters— À paraîtreà paraître
10. Constructeurs et mot-clé this— À paraîtreà paraître
11. Exercice : un CompteBancaire qu’on ne peut pas casser— À paraîtreà paraître
12. Quiz : encapsulation et constructeurs— À paraîtreà paraître
13. Surcharge de méthodes— À paraîtreà paraître
14. static : ce qui appartient à la classe— À paraîtreà paraître
15. Héritage : extends et super— À paraîtreà paraître
16. Redéfinir une méthode : @Override— À paraîtreà paraître
17. Exercice : Vehicule, Voiture, Moto— À paraîtreà paraître
18. Polymorphisme : une référence parente, plusieurs comportements— À paraîtreà paraître
19. Exercice : calculer une masse salariale polymorphe— À paraîtreà paraître
20. Classes abstraites— À paraîtreà paraître
21. Interfaces en Java 11— À paraîtreà paraître
22. Interface ou classe abstraite : comment choisir— À paraîtreà paraître
23. Exercice : le Garage— À paraîtreà paraître
24. Quiz : héritage, polymorphisme, abstraction— À paraîtreà paraître
25. Relations entre objets : composition, agrégation, association— À paraîtreà paraître
26. Le minimum vital sur List<T>— À paraîtreà paraître
27. Exercice : mini-bibliothèque (Livre, Membre, Emprunt)— À paraîtreà paraître
28. toString, equals et le piège du ==— À paraîtreà paraître
29. Packages et import— À paraîtreà paraître
30. Exceptions : try, catch, finally— À paraîtreà paraître
31. throws, exceptions vérifiées et exceptions personnalisées— À paraîtreà paraître
32. Annotations— À paraîtreà paraître
33. Ce que la POO change dans un projet de test— À paraîtreà paraître
34. Un premier Page Object— À paraîtreà paraître
35. Exercice guidé : LoginPage sur SwagLabs— À paraîtreà paraître
36. Évaluation finale du module— À paraîtreà paraître
37. Kit du module : mémo, corrigés, projet de référence— À paraîtreà paraître
M7 Consolidation : sept mini-projets Java0/29
1. Ce que vous allez construire— À paraîtreà paraître
2. Rappel express : les 14 concepts POO en fiches— À paraîtreà paraître
3. Auto-diagnostic : êtes-vous prêt ?— À paraîtreà paraître
4. Votre atelier : projet, packages, exécution— À paraîtreà paraître
5. Décoder les erreurs du compilateur Java— À paraîtreà paraître
6. Fiche : les 8 types primitifs— À paraîtreà paraître
7. Choisir sa collection : List, Set, Map— À paraîtreà paraître
8. Mini-projet 1 : gestion d’une bibliothèque— À paraîtreà paraître
9. Correction commentée du mini-projet 1— À paraîtreà paraître
10. Mini-projet 2 : calculatrice et surcharge— À paraîtreà paraître
11. Correction du mini-projet 2 : les exceptions— À paraîtreà paraître
12. Quiz : surcharge, redéfinition, exceptions— À paraîtreà paraître
13. Mini-projet 3 : système de paiement— À paraîtreà paraître
14. Correction du mini-projet 3 : à quoi sert l’interface— À paraîtreà paraître
15. Modéliser avant de coder— À paraîtreà paraître
16. Classe abstraite ou interface ? Héritage ou composition ?— À paraîtreà paraître
17. Mini-projet 4 (1/2) : la hiérarchie Personne— À paraîtreà paraître
18. Mini-projet 4 (2/2) : interface Diplome, Ecole et scénario main— À paraîtreà paraître
19. Correction du mini-projet 4— À paraîtreà paraître
20. Mini-projet 5 (1/2) : la hiérarchie Produit— À paraîtreà paraître
21. Mini-projet 5 (2/2) : Stock, Magasin, Employe— À paraîtreà paraître
22. Correction du mini-projet 5 : les collections imbriquées— À paraîtreà paraître
23. static et annotations, pour de vrai— À paraîtreà paraître
24. Mini-projet 6 : Entreprise, Ecole et Magasin— À paraîtreà paraître
25. Mini-projet 7 : gestion d’un zoo, le projet final— À paraîtreà paraître
26. Débogage : 5 bugs à trouver— À paraîtreà paraître
27. De la POO au framework de test— À paraîtreà paraître
28. Quiz bilan du module— À paraîtreà paraître
29. Banque d’entraînement : 14 exercices POO— À paraîtreà paraître
M8 Selenium : comprendre l’outil et préparer le projet0/9
1. Décider si un test mérite d’être automatisé— À paraîtreà paraître
2. Selenium n’est pas un framework de test— À paraîtreà paraître
3. Comment WebDriver pilote réellement un navigateur— À paraîtreà paraître
4. Quiz — situer Selenium dans son écosystème— À paraîtreà paraître
5. Le DOM vu par un testeur— À paraîtreà paraître
6. Inspecter une page avec les DevTools— Non commencé
7. Créer le projet Maven de test— À paraîtreà paraître
8. Premier script : ouvrir, lire, fermer— Non commencé
9. Diagnostiquer les 8 erreurs de démarrage— À paraîtreà paraître
M9 Localiser un élément : DOM, XPath, CSS0/10
1. La classe By : les 8 stratégies— À paraîtreà paraître
2. Choisir un localisateur qui résiste au temps— À paraîtreà paraître
3. XPath 1 : chemins absolus, chemins relatifs, et le piège du //— À paraîtreà paraître
4. XPath 2 : prédicats, attributs, texte— À paraîtreà paraître
5. XPath 3 : position, et la parenthèse qui change tout— À paraîtreà paraître
6. XPath 4 : les axes, remonter et se déplacer dans le DOM— À paraîtreà paraître
7. Ce que XPath sait faire et que Selenium refuse— À paraîtreà paraître
8. Atelier : 12 XPath validés dans la console— Non commencé
9. Les sélecteurs CSS, et quand les préférer à XPath— À paraîtreà paraître
10. Quiz : choisir le bon localisateur— À paraîtreà paraître
M10 Agir, vérifier, fiabiliser0/22
1. findElement et findElements— À paraîtreà paraître
2. Agir sur un élément : clear, sendKeys, click, submit, getText— À paraîtreà paraître
3. TP guidé : s’authentifier sur OrangeHRM— À paraîtreà paraître
4. TP guidé : lire et modifier une fiche— À paraîtreà paraître
5. WebElement : les méthodes d’état et d’inspection— À paraîtreà paraître
6. Listes déroulantes : Select natif et faux select— À paraîtreà paraître
7. TP : formulaire multi-champs et vérification de ligne— À paraîtreà paraître
8. La classe Actions : clavier et souris— À paraîtreà paraître
9. TP : survol, clic droit et glisser-déposer— À paraîtreà paraître
10. Vérifier n’est pas asserter— À paraîtreà paraître
11. Assertions JUnit et TestNG : choisir et ne pas inverser— À paraîtreà paraître
12. Assertions douces et messages d’échec— À paraîtreà paraître
13. TP : transformer un scénario en test assertif— À paraîtreà paraître
14. Pourquoi un test passe une fois sur deux— À paraîtreà paraître
15. Le wait implicite— À paraîtreà paraître
16. Wait explicite et ExpectedConditions— À paraîtreà paraître
17. Fluent wait, Thread.sleep et le mélange interdit— À paraîtreà paraître
18. TP : fiabiliser un test instable— À paraîtreà paraître
19. Quiz — synchronisation— À paraîtreà paraître
20. Piloter la fenêtre du navigateur— À paraîtreà paraître
21. ChromeOptions : incognito, headless, téléchargements— À paraîtreà paraître
22. TP : exécuter la même suite en headless— À paraîtreà paraître
M11 Industrialiser : TestNG, Maven et Page Object Model0/11
1. TestNG : les annotations et l’ordre d’exécution— À paraîtreà paraître
2. testng.xml : suites, groupes et exécution parallèle— À paraîtreà paraître
3. Paramétrer un test : @Parameters et @DataProvider— À paraîtreà paraître
4. Maven : cycle de vie et lancement des tests— À paraîtreà paraître
5. Allure : le rapport et la capture d’écran sur échec— À paraîtreà paraître
6. Générer des jeux de données sans collision— À paraîtreà paraître
7. Le Page Object Model : séparer la page du test— À paraîtreà paraître
8. Lire l’architecture du framework Pandora— À paraîtreà paraître
9. Ce que Selenium ne sait pas faire— À paraîtreà paraître
10. Projet fil rouge : une campagne de bout en bout— À paraîtreà paraître
11. Examen final du module— À paraîtreà paraître
M12 Le framework Pandora0/29
1. Pourquoi un framework plutôt que des scripts Selenium— À paraîtreà paraître
2. Installer Maven et Allure— À paraîtreà paraître
3. Checklist : mon poste est-il prêt ?— À paraîtreà paraître
4. Créer le projet Maven dans VSCode— À paraîtreà paraître
5. Greffer le package Pandora sur le projet— À paraîtreà paraître
6. Lire l’arborescence Pandora— À paraîtreà paraître
7. Le cœur du framework : TestBase, Factory, Utilities— À paraîtreà paraître
8. Le Listener et la capture d’écran automatique— À paraîtreà paraître
9. Pojo : centraliser ses locators— À paraîtreà paraître
10. Quiz : l’architecture de Pandora— À paraîtreà paraître
11. Le cycle de vie TestNG : les huit annotations— À paraîtreà paraître
12. Écrire son premier cas de test Pandora— À paraîtreà paraître
13. Suites TestNG et campagnes Maven— À paraîtreà paraître
14. Lancer une campagne en ligne de commande— À paraîtreà paraître
15. Récupérer un paramètre -D dans son code— À paraîtreà paraître
16. Lire un rapport Allure— À paraîtreà paraître
17. Surefire, JUnit et les logs— À paraîtreà paraître
18. Quiz : exécution et reporting— À paraîtreà paraître
19. Groupes TestNG et dépendances entre tests— À paraîtreà paraître
20. DataProvider : piloter un test par les données— À paraîtreà paraître
21. Assertions TestNG et pilotage d’un test— À paraîtreà paraître
22. Iframes, onglets et fenêtres : changer de contexte— À paraîtreà paraître
23. Cookies et alertes JavaScript— À paraîtreà paraître
24. La classe Actions— À paraîtreà paraître
25. JavascriptExecutor : le dernier recours— À paraîtreà paraître
26. Upload de fichier : sendKeys d’abord, Robot ensuite— À paraîtreà paraître
27. Ajouter une dépendance Maven— À paraîtreà paraître
28. Mon test ne passe pas : guide de dépannage— À paraîtreà paraître
29. Projet fil rouge : une campagne complète— À paraîtreà paraître
M13 Mises en situation : quatre applications réelles0/53
1. Ce qui change : du TP guidé au projet réel— À paraîtreà paraître
2. Les quatre projets, leur ordre et sa raison— À paraîtreà paraître
3. Lire une user story et en extraire des cas de test— À paraîtreà paraître
4. Exercice : dériver les cas de test de l’US1 Swag Labs— À paraîtreà paraître
5. La matrice de couverture : user stories et cas de test— À paraîtreà paraître
6. Le squelette de projet imposé— À paraîtreà paraître
7. Exercice : monter le projet socle et le faire tourner— À paraîtreà paraître
8. Le Page Object Model en 20 minutes— À paraîtreà paraître
9. Exercice : un premier Page Object— À paraîtreà paraître
10. Choisir un bon localisateur— À paraîtreà paraître
11. Quiz : cadrage et socle technique— À paraîtreà paraître
12. Projet 1 — Swag Labs : l’application et son jeu de données— À paraîtreà paraître
13. Projet 1 — US1 : la page de connexion— À paraîtreà paraître
14. Projet 1 — US1 : les cinq cas d’erreur et leurs textes exacts— À paraîtreà paraître
15. Projet 1 — US2 : la page d’inventaire— À paraîtreà paraître
16. Projet 1 — Isolation des tests et Reset App State— À paraîtreà paraître
17. Projet 1 — US3 : le tri des produits— À paraîtreà paraître
18. Projet 1 — US4 : le panier et son badge— À paraîtreà paraître
19. Projet 1 — US5 : le tunnel de commande, étape informations— À paraîtreà paraître
20. Projet 1 — US6 : récapitulatif, total et confirmation— À paraîtreà paraître
21. Projet 1 — Corrigé commenté et revue de code— À paraîtreà paraître
22. Quiz : projet 1, Swag Labs— À paraîtreà paraître
23. Projet 2 — Rent a CAR : cadrage et carte des risques— À paraîtreà paraître
24. Projet 2 — US2 : recherche par dates et heures— À paraîtreà paraître
25. Projet 2 — US3 : trois vues, un seul jeu de tests— À paraîtreà paraître
26. Projet 2 — US3 : parcourir un tableau paginé et trié— À paraîtreà paraître
27. Projet 2 — US4 : popup de détail et onglets— À paraîtreà paraître
28. Projet 2 — US5 : Daily Schedule, double-clic et réservation— À paraîtreà paraître
29. Projet 2 — US1 et US6 : tester une application multilingue— À paraîtreà paraître
30. Quiz : projet 2, Rent a CAR— À paraîtreà paraître
31. Projet 3 — Ce que Selenium sait faire, et ce qu’il ne sait pas faire— À paraîtreà paraître
32. Projet 3 — Localiser des éléments graphiques SVG— À paraîtreà paraître
33. Projet 3 — US3 : glisser-déposer, redimensionner, supprimer— À paraîtreà paraître
34. Projet 3 — US1 : Open et Save, fichiers et dialogues natifs— À paraîtreà paraître
35. Projet 3 — US2, US5, US6 et US7 : le reste de l’outil— À paraîtreà paraître
36. Projet 3 — Rédiger une note de non-automatisation— À paraîtreà paraître
37. Quiz : projet 3 et limites de Selenium— À paraîtreà paraître
38. Projet 4 — Cahier des charges et livrable attendu— À paraîtreà paraître
39. Projet 4 — US2 : le champ à autocomplétion— À paraîtreà paraître
40. Projet 4 — US3 : carousel, survol et descriptions— À paraîtreà paraître
41. Projet 4 — US4 et US5 : destinations et fiche détaillée— À paraîtreà paraître
42. Projet 4 — US6 : vérifier un effet visuel— À paraîtreà paraître
43. Projet 4 — US7 : le formulaire de contact complet— À paraîtreà paraître
44. Changer de contexte : frames, fenêtres et alertes— À paraîtreà paraître
45. Diagnostiquer un test qui échoue— À paraîtreà paraître
46. Exercice : réparer six tests cassés— À paraîtreà paraître
47. Stabiliser : en finir avec les tests intermittents— À paraîtreà paraître
48. La capture d’écran automatique en cas d’échec— À paraîtreà paraître
49. Produire le rapport de campagne : Surefire et Allure— À paraîtreà paraître
50. Organiser ses suites et exécuter en parallèle— À paraîtreà paraître
51. Livrer un dépôt Git propre— À paraîtreà paraître
52. Grille d’auto-évaluation et rendu final— À paraîtreà paraître
53. Quiz final de mise en situation— À paraîtreà paraître
M14 Se situer et entrer sur le marché0/20
1. Pourquoi automatiser — et quand s’en abstenir— À paraîtreà paraître
2. Calculer le point d’équilibre d’une suite automatisée— À paraîtreà paraître
3. Fonctionnel, non fonctionnel, pyramide des tests— À paraîtreà paraître
4. Exercice : trier douze cas de test à automatiser ou non— À paraîtreà paraître
5. Quiz — rentabilité, limites et typologie des tests— À paraîtreà paraître
6. Panorama des outils d’automatisation web— À paraîtreà paraître
7. Outils d’API, de performance, de mobile et de test visuel— À paraîtreà paraître
8. Où s’exécutent les tests : CI/CD et intégration continue— À paraîtreà paraître
9. Choisir son outil : grille de décision et trois études de cas— À paraîtreà paraître
10. Quel langage pour automatiser : Java, Python, JavaScript, C#— À paraîtreà paraître
11. Quiz — outils et langages— À paraîtreà paraître
12. Le parcours de certification ISTQB— À paraîtreà paraître
13. Les niveaux du métier, de testeur junior à architecte de test— À paraîtreà paraître
14. Construire son CV et son profil LinkedIn de QA automaticien— À paraîtreà paraître
15. L’entretien technique : vingt questions et les réponses attendues— À paraîtreà paraître
16. La boîte à outils du QA automaticien— À paraîtreà paraître
17. Trente ressources à garder sous la main, classées par usage— À paraîtreà paraître
18. Organiser sa veille et situer ce que l’IA change dans le test— À paraîtreà paraître
19. Mon plan à 90 jours après le Niveau 1— À paraîtreà paraître
20. Quiz final du module— À paraîtreà paraître
M15 Évaluation finale0/21
1. Les épreuves, le barème et le nombre de tentatives— À paraîtreà paraître
2. Test de positionnement d’entrée— À paraîtreà paraître
3. QCM — Algorithmique— À paraîtreà paraître
4. Corrigé commenté — Algorithmique— À paraîtreà paraître
5. QCM — Java, les fondations— À paraîtreà paraître
6. Corrigé commenté — Java, les fondations— À paraîtreà paraître
7. QCM — Programmation orientée objet— À paraîtreà paraître
8. Corrigé commenté — POU : les pièges de vocabulaire— À paraîtreà paraître
9. QCM — Java intermédiaire— À paraîtreà paraître
10. QCM — HTML, DOM, XPath et sélecteurs CSS— À paraîtreà paraître
11. QCM Selenium 1 — composants, WebDriver, localisateurs— À paraîtreà paraître
12. QCM Selenium 2 — attentes, Actions, Select, assertions— À paraîtreà paraître
13. Corrigé commenté — Selenium et l’API Selenium 4— À paraîtreà paraître
14. QCM outillage — Maven, JUnit, TestNG, structure de projet— À paraîtreà paraître
15. Exercice noté 1 — Déboguer un test qui ment— À paraîtreà paraître
16. Exercice noté 2 — Écrire un test complet sur SwagLabs— À paraîtreà paraître
17. Examen final, partie A — QCM auto-corrigé— À paraîtreà paraître
18. Examen final, partie B — Questions ouvertes et auto-évaluation guidée— À paraîtreà paraître
19. Examen final, partie C — Projet pratique évalué— À paraîtreà paraître
20. Le résultat, bloc par bloc, et le plan de reprise— À paraîtreà paraître
21. Banque de révision et fiches d’erreurs fréquentes— À paraîtreà paraître