-Bonjour à tous.
Dans cette vidéo, on va s'intéresser de plus près au Debugger
et à comment vous en servir pour contrôler l'exécution d'un test
ou déboguer un de vos tests, tout simplement.
Pour ça, j'ai repris le package "MyCounter",
qu'on a développé dans le redo des semaines 1 et 2.
On va s'intéresser au test de la méthode "decrement".
Pour ouvrir le Debugger sur un de vos tests,
il vous suffit de faire clic droit et d'aller dans Debug Tests
ou de faire Cmd+D, le raccourci.
On clique.
On voit qu'il y a marqué "Break", ici,
c'est parce que le système a mis un breakpoint
directement sur la méthode de test.
Si on s'intéresse de plus près au Debugger,
il y a trois zones.
La zone du haut correspond à la pile d'exécutions.
Vous pouvez voir qu'il y a énormément de méthodes
qui ont amené à l'exécution de notre test.
Ce sont des méthodes graphiques ou de gestion de processus,
ça ne nous intéresse pas, ici.
On va plutôt s'intéresser
à notre méthode "testCounterDecrement",
tout en haut de la pile, qui est surlignée ici,
parce que là, on va avoir la source, le corps de toutes les méthodes
qui vont être exécutées par le Debugger.
Enfin, en dessous, on va avoir les variables
qui sont actuellement gérées par le système
et leur valeur au moment où on est dans la pile d'exécutions.
C'est-à-dire que maintenant,
je vais pouvoir utiliser les fonctionnalités qu'on a en haut.
"Proceed" permet de continuer les exécutions
jusqu'à ce qu'il y ait une nouvelle erreur
ou que la méthode soit complétée.
"Restart" relance l'exécution,
et on va s'intéresser un peu plus à "Into" et "Over".
Je vous montre à quoi ça sert.
On va commencer par presser "Over" et on va voir que, maintenant,
on se retrouve dans l'exécution de la méthode "startingAt".
Ce qui est intéressant, avec "Over" et "Into",
c'est que "Into" va nous permettre
d'aller à l'intérieur du corps de méthode de "startingAt",
alors que "Over" va continuer l'exécution d'un cran.
Par exemple, on va cliquer sur "Into", ici.
On va se retrouver un niveau après sur la pile d'exécutions,
mais, cette fois-ci, dans une méthode envoyée à la classe "Counter",
la méthode "startingAt", qui est ici.
On peut itérer à nouveau sur les méthodes qui sont envoyées ici.
Il n'y a pas grand-chose à itérer, donc on va simplement presser "Over".
Et "count", par exemple, on va aller à l'intérieur
pour voir le corps de méthode. "Into".
On se retrouve dans la méthode "count", dans la classe "Counter".
C'est un setter, donc rien d'extraordinaire,
mais on peut accéder à ce code
et on peut même voir la valeur de l'entier, ici.
C'est-à-dire que "anInteger", dans notre cas, ça vaut 5.
On peut s'intéresser à "count", Cmd+P.
Pour l'instant, il vaut "nil".
On peut aussi le voir en bas.
Il est défini comme attribute, variable d'instance,
donc pour l'instant, il vaut "nil".
On va presser "Over". La méthode va être exécutée.
"Over". On se retrouve ici.
On peut voir que le paramètre "anInteger" vaut 5
et que "c" vaut un compteur, avec la variable "count", qui vaut 5.
On va pouvoir appuyer sur "Over".
Le compteur va être rendu.
On se retrouve ici
et on voit que notre compteur "c" vaut toujours "nil".
Maintenant, juste après ce message surligné,
c'est une affectation,
notre compteur devrait être un nouveau compteur
avec une variable qui vaut 5.
On appuie sur "Over" et on a maintenant un compteur dans "c".
Dans "Raw", l'attribut "count" vaut bien 5.
On peut rappuyer sur "Over".
On va avoir un appel à "decrement".
On regarde dans le compteur
si le premier appel a bien été exécuté.
On voit que ça vaut bien 4.
On peut retourner voir le code source de "decrement"
en pressant "Into".
On peut même évaluer "count" directement ici, qui vaut 4.
Ce count-là aussi vaut 4,
et, si tout va bien, le résultat devrait valoir 3.
On peut appuyer sur "Over". Une fois, deux fois.
Et en appuyant sur "Over",
on se retrouve directement dans la méthode "count"
et, normalement, on devrait avoir notre compteur
qui a subi les deux méthodes "decrement".
Sa variable d'instance devrait valoir 3, et c'est le cas.
On peut vérifier ça ici.
C'est un environnement dans lequel on peut travailler,
il suffit de presser "Print" ou Cmd+P pour voir que ça vaut 3.
Il n'y a pas de souci dans l'exécution de cette méthode
donc "Proceed".
C'était un aperçu du Debugger.
Une autre chose intéressante,
c'est que ça ne se limite pas forcément aux tests ou aux méthodes.
On peut aussi, par exemple, ouvrir le Playground,
copier ce code,
et on peut le déboguer tout de suite en faisant clic droit
et "Debug it", Cmd+shift+D.
Ça nous ouvre un Debugger qui est un peu plus spécifique,
mais dans lequel on peut faire les mêmes actions.
C'est-à-dire qu'on peut toujours faire "Into", "Over",
on va se retrouver dans la même chose.
"Over", on peut aller dans la méthode "decrement".
Donc, le même type de navigation, toujours dans un environnement
dans lequel on peut inspecter les choses.
Ici, ça vaut 4, on va voir que ça, ça vaut 5.
Le Debugger est un outil très puissant
qui permet de modifier directement la méthode d'ici.
Si la méthode "decrement" ne me plaît pas,
je peux dire qu'elle va enlever 2.
Le point orange dit que ça n'a pas été sauvegardé, je sauvegarde.
Quand je quitte, on peut relancer notre test.
Notre test "decrement" ne devrait pas marcher, puisque "decrement" fait -2.
On voit que le test n'a pas marché.
Le Debugger est un outil extrêmement puissant
que je vous encourage à utiliser,
car il va faciliter la compréhension des méthodes que vous avez
et aussi la manière dont vous allez interagir avec votre code.