1
00:00:04,480 --> 00:00:05,280
-Bonjour à tous.

2
00:00:05,600 --> 00:00:08,160
Dans cette vidéo, on va s'intéresser
de plus près au Debugger

3
00:00:08,480 --> 00:00:11,760
et à comment vous en servir
pour contrôler l'exécution d'un test

4
00:00:12,080 --> 00:00:13,920
ou déboguer un de vos tests,
tout simplement.

5
00:00:14,240 --> 00:00:17,440
Pour ça,
j'ai repris le package "MyCounter",

6
00:00:17,760 --> 00:00:20,040
qu'on a développé dans le redo
des semaines 1 et 2.

7
00:00:20,360 --> 00:00:23,200
On va s'intéresser
au test de la méthode "decrement".

8
00:00:23,520 --> 00:00:25,480
Pour ouvrir le Debugger
sur un de vos tests,

9
00:00:25,800 --> 00:00:29,160
il vous suffit de faire clic droit
et d'aller dans Debug Tests

10
00:00:29,480 --> 00:00:31,720
ou de faire Cmd+D, le raccourci.

11
00:00:32,040 --> 00:00:32,960
On clique.

12
00:00:33,280 --> 00:00:35,320
On voit qu'il y a marqué "Break",
ici,

13
00:00:35,640 --> 00:00:38,240
c'est parce que le système
a mis un breakpoint

14
00:00:38,560 --> 00:00:40,480
directement sur la méthode de test.

15
00:00:40,800 --> 00:00:42,480
Si on s'intéresse de plus près
au Debugger,

16
00:00:42,800 --> 00:00:43,840
il y a trois zones.

17
00:00:44,160 --> 00:00:46,800
La zone du haut
correspond à la pile d'exécutions.

18
00:00:47,120 --> 00:00:49,120
Vous pouvez voir
qu'il y a énormément de méthodes

19
00:00:49,440 --> 00:00:51,440
qui ont amené
à l'exécution de notre test.

20
00:00:51,760 --> 00:00:55,440
Ce sont des méthodes graphiques
ou de gestion de processus,

21
00:00:55,760 --> 00:00:57,120
ça ne nous intéresse pas, ici.

22
00:00:57,440 --> 00:00:58,680
On va plutôt s'intéresser

23
00:00:59,000 --> 00:01:00,880
à notre méthode "testCounterDecrement",

24
00:01:01,200 --> 00:01:03,480
tout en haut de la pile,
qui est surlignée ici,

25
00:01:03,800 --> 00:01:07,720
parce que là, on va avoir la source,
le corps de toutes les méthodes

26
00:01:08,040 --> 00:01:09,680
qui vont être exécutées
par le Debugger.

27
00:01:10,000 --> 00:01:12,960
Enfin, en dessous,
on va avoir les variables

28
00:01:13,280 --> 00:01:15,120
qui sont actuellement gérées
par le système

29
00:01:15,440 --> 00:01:18,400
et leur valeur au moment où on est
dans la pile d'exécutions.

30
00:01:18,720 --> 00:01:20,040
C'est-à-dire que maintenant,

31
00:01:20,360 --> 00:01:22,840
je vais pouvoir utiliser
les fonctionnalités qu'on a en haut.

32
00:01:23,160 --> 00:01:25,040
"Proceed" permet
de continuer les exécutions

33
00:01:25,360 --> 00:01:27,120
jusqu'à ce qu'il y ait
une nouvelle erreur

34
00:01:27,440 --> 00:01:28,800
ou que la méthode soit complétée.

35
00:01:29,120 --> 00:01:30,480
"Restart" relance l'exécution,

36
00:01:30,800 --> 00:01:33,720
et on va s'intéresser
un peu plus à "Into" et "Over".

37
00:01:34,040 --> 00:01:35,360
Je vous montre à quoi ça sert.

38
00:01:35,680 --> 00:01:39,080
On va commencer par presser "Over"
et on va voir que, maintenant,

39
00:01:39,400 --> 00:01:43,160
on se retrouve dans l'exécution
de la méthode "startingAt".

40
00:01:43,480 --> 00:01:45,680
Ce qui est intéressant,
avec "Over" et "Into",

41
00:01:46,000 --> 00:01:47,440
c'est que "Into" va nous permettre

42
00:01:47,760 --> 00:01:51,080
d'aller à l'intérieur
du corps de méthode de "startingAt",

43
00:01:51,400 --> 00:01:54,000
alors que "Over"
va continuer l'exécution d'un cran.

44
00:01:54,320 --> 00:01:56,040
Par exemple,
on va cliquer sur "Into", ici.

45
00:01:56,360 --> 00:01:59,640
On va se retrouver un niveau après
sur la pile d'exécutions,

46
00:01:59,960 --> 00:02:02,800
mais, cette fois-ci, dans une méthode
envoyée à la classe "Counter",

47
00:02:03,120 --> 00:02:04,680
la méthode "startingAt", qui est ici.

48
00:02:05,000 --> 00:02:08,080
On peut itérer à nouveau
sur les méthodes qui sont envoyées ici.

49
00:02:08,400 --> 00:02:13,560
Il n'y a pas grand-chose à itérer,
donc on va simplement presser "Over".

50
00:02:13,880 --> 00:02:15,880
Et "count", par exemple,
on va aller à l'intérieur

51
00:02:16,200 --> 00:02:17,800
pour voir le corps de méthode.
"Into".

52
00:02:18,120 --> 00:02:20,760
On se retrouve dans la méthode
"count", dans la classe "Counter".

53
00:02:21,080 --> 00:02:23,280
C'est un setter,
donc rien d'extraordinaire,

54
00:02:23,600 --> 00:02:25,000
mais on peut accéder à ce code

55
00:02:25,320 --> 00:02:27,640
et on peut même voir
la valeur de l'entier, ici.

56
00:02:27,960 --> 00:02:30,480
C'est-à-dire que "anInteger",
dans notre cas, ça vaut 5.

57
00:02:30,800 --> 00:02:32,920
On peut s'intéresser à "count", Cmd+P.

58
00:02:33,240 --> 00:02:34,440
Pour l'instant, il vaut "nil".

59
00:02:34,760 --> 00:02:36,160
On peut aussi le voir en bas.

60
00:02:36,480 --> 00:02:38,560
Il est défini comme attribute,
variable d'instance,

61
00:02:38,880 --> 00:02:40,400
donc pour l'instant, il vaut "nil".

62
00:02:40,720 --> 00:02:43,840
On va presser "Over".
La méthode va être exécutée.

63
00:02:44,160 --> 00:02:46,400
"Over". On se retrouve ici.

64
00:02:46,720 --> 00:02:48,840
On peut voir
que le paramètre "anInteger" vaut 5

65
00:02:49,160 --> 00:02:52,680
et que "c" vaut un compteur,
avec la variable "count", qui vaut 5.

66
00:02:53,000 --> 00:02:54,480
On va pouvoir appuyer sur "Over".

67
00:02:55,440 --> 00:02:56,760
Le compteur va être rendu.

68
00:02:57,080 --> 00:02:57,960
On se retrouve ici

69
00:02:58,280 --> 00:03:00,960
et on voit que notre compteur "c"
vaut toujours "nil".

70
00:03:01,280 --> 00:03:03,360
Maintenant,
juste après ce message surligné,

71
00:03:03,680 --> 00:03:05,000
c'est une affectation,

72
00:03:05,320 --> 00:03:07,440
notre compteur
devrait être un nouveau compteur

73
00:03:07,760 --> 00:03:08,960
avec une variable qui vaut 5.

74
00:03:09,280 --> 00:03:12,800
On appuie sur "Over" et on a
maintenant un compteur dans "c".

75
00:03:13,120 --> 00:03:15,720
Dans "Raw",
l'attribut "count" vaut bien 5.

76
00:03:16,040 --> 00:03:17,200
On peut rappuyer sur "Over".

77
00:03:17,520 --> 00:03:19,040
On va avoir un appel à "decrement".

78
00:03:19,360 --> 00:03:20,440
On regarde dans le compteur

79
00:03:20,760 --> 00:03:22,440
si le premier appel a bien été exécuté.

80
00:03:22,760 --> 00:03:23,960
On voit que ça vaut bien 4.

81
00:03:24,280 --> 00:03:26,640
On peut retourner voir
le code source de "decrement"

82
00:03:26,960 --> 00:03:28,800
en pressant "Into".

83
00:03:29,120 --> 00:03:32,160
On peut même évaluer "count"
directement ici, qui vaut 4.

84
00:03:32,480 --> 00:03:33,760
Ce count-là aussi vaut 4,

85
00:03:34,080 --> 00:03:36,200
et, si tout va bien,
le résultat devrait valoir 3.

86
00:03:36,520 --> 00:03:39,120
On peut appuyer sur "Over".
Une fois, deux fois.

87
00:03:39,440 --> 00:03:40,640
Et en appuyant sur "Over",

88
00:03:40,960 --> 00:03:43,000
on se retrouve directement
dans la méthode "count"

89
00:03:43,320 --> 00:03:45,400
et, normalement,
on devrait avoir notre compteur

90
00:03:45,720 --> 00:03:47,680
qui a subi
les deux méthodes "decrement".

91
00:03:48,000 --> 00:03:50,800
Sa variable d'instance
devrait valoir 3, et c'est le cas.

92
00:03:51,120 --> 00:03:52,120
On peut vérifier ça ici.

93
00:03:52,440 --> 00:03:54,560
C'est un environnement
dans lequel on peut travailler,

94
00:03:54,880 --> 00:03:57,680
il suffit de presser "Print" ou Cmd+P
pour voir que ça vaut 3.

95
00:03:58,000 --> 00:04:00,360
Il n'y a pas de souci
dans l'exécution de cette méthode

96
00:04:00,680 --> 00:04:01,440
donc "Proceed".

97
00:04:01,760 --> 00:04:03,360
C'était un aperçu du Debugger.

98
00:04:03,680 --> 00:04:04,880
Une autre chose intéressante,

99
00:04:05,200 --> 00:04:07,960
c'est que ça ne se limite pas
forcément aux tests ou aux méthodes.

100
00:04:08,280 --> 00:04:10,680
On peut aussi, par exemple,
ouvrir le Playground,

101
00:04:11,000 --> 00:04:12,480
copier ce code,

102
00:04:12,800 --> 00:04:15,480
et on peut le déboguer tout de suite
en faisant clic droit

103
00:04:15,800 --> 00:04:18,680
et "Debug it", Cmd+shift+D.

104
00:04:19,000 --> 00:04:21,920
Ça nous ouvre un Debugger
qui est un peu plus spécifique,

105
00:04:22,240 --> 00:04:24,320
mais dans lequel
on peut faire les mêmes actions.

106
00:04:24,640 --> 00:04:28,320
C'est-à-dire qu'on peut toujours
faire "Into", "Over",

107
00:04:28,640 --> 00:04:30,280
on va se retrouver dans la même chose.

108
00:04:30,600 --> 00:04:32,800
"Over", on peut aller
dans la méthode "decrement".

109
00:04:33,120 --> 00:04:36,160
Donc, le même type de navigation,
toujours dans un environnement

110
00:04:36,480 --> 00:04:38,160
dans lequel
on peut inspecter les choses.

111
00:04:38,480 --> 00:04:40,880
Ici, ça vaut 4,
on va voir que ça, ça vaut 5.

112
00:04:41,200 --> 00:04:42,960
Le Debugger est un outil très puissant

113
00:04:43,280 --> 00:04:45,600
qui permet de modifier directement
la méthode d'ici.

114
00:04:45,920 --> 00:04:47,600
Si la méthode "decrement"
ne me plaît pas,

115
00:04:47,920 --> 00:04:49,320
je peux dire qu'elle va enlever 2.

116
00:04:49,640 --> 00:04:52,600
Le point orange dit que ça n'a pas
été sauvegardé, je sauvegarde.

117
00:04:52,920 --> 00:04:54,720
Quand je quitte,
on peut relancer notre test.

118
00:04:55,040 --> 00:04:58,160
Notre test "decrement" ne devrait pas
marcher, puisque "decrement" fait -2.

119
00:04:58,480 --> 00:04:59,960
On voit que le test n'a pas marché.

120
00:05:00,280 --> 00:05:02,320
Le Debugger
est un outil extrêmement puissant

121
00:05:02,640 --> 00:05:04,000
que je vous encourage à utiliser,

122
00:05:04,320 --> 00:05:07,040
car il va faciliter la compréhension
des méthodes que vous avez

123
00:05:07,360 --> 00:05:10,480
et aussi la manière dont vous allez
interagir avec votre code.