\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Tests et débogage}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Tests et débogage} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{premieretestsdebogage}{
  \begin{question}{q01}
    Qu'appelle-t-on un \textbf{test} dans le
contexte du logiciel ?
    \begin{choices}
    \correctchoice{Une vérification automatique qu'un programme se comporte comme attendu sur des entrées choisies}
    \wrongchoice{Un type particulier de variable}
    \wrongchoice{Une question à choix multiple posée à l'utilisateur}
    \wrongchoice{Un avertissement émis par le langage Python}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q02}
    Que fait l'instruction \texttt{assert
condition} en Python ?
    \begin{choices}
    \correctchoice{Si la condition est fausse, elle lève une exception \texttt{AssertionError} ; sinon, elle ne fait rien}
    \wrongchoice{Elle affiche la condition à l'écran}
    \wrongchoice{Elle convertit la condition en booléen}
    \wrongchoice{Elle ne fonctionne qu'en mode débogage}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q03}
    Qu'est-ce qu'un \textbf{test unitaire} ?
    \begin{choices}
    \wrongchoice{Un test sans coût}
    \wrongchoice{Un test qui couvre tout le programme}
    \wrongchoice{Un test qui dure très longtemps}
    \correctchoice{Un test qui vérifie le comportement d'une seule fonction (une « unité » de code) sur des entrées spécifiques}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q04}
    Quelle ligne \textbf{teste} que \texttt{carre(3)
== 9} ?
    \begin{choices}
    \wrongchoice{\texttt{if carre(3) != 9: print("erreur")}}
    \correctchoice{\texttt{assert carre(3) == 9}}
    \wrongchoice{\texttt{carre(3)}}
    \wrongchoice{\texttt{test carre(3) == 9}}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q05}
    Quand Python lève une \textbf{erreur}, où
regarder pour comprendre ce qui se
passe ?
    \begin{choices}
    \wrongchoice{Le code source du module Python lui-même}
    \wrongchoice{Les paramètres du système d'exploitation}
    \wrongchoice{Sur Internet, en cherchant un message proche}
    \correctchoice{La trace d'erreur affichée par Python, qui indique le fichier, la ligne concernée et le type d'erreur}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q06}
    À quoi sert un appel à \texttt{print} dans
un objectif de \textbf{débogage} ?
    \begin{choices}
    \wrongchoice{À empêcher d'écrire d'autres lignes de code}
    \wrongchoice{À encoder des données en hexadécimal}
    \correctchoice{À afficher la valeur d'une variable à un moment précis du programme, pour suivre son déroulement}
    \wrongchoice{À ralentir intentionnellement le programme}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q07}
    Qu'est-ce qu'un \textbf{bug} ?
    \begin{choices}
    \correctchoice{Une erreur ou un comportement non conforme aux spécifications du programme}
    \wrongchoice{Une fonctionnalité que l'utilisateur n'a pas demandée}
    \wrongchoice{Une nouvelle version d'un logiciel}
    \wrongchoice{Un type particulier de mémoire}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q08}
    Qu'est-ce qu'un \textbf{jeu d'essais} ?
    \begin{choices}
    \wrongchoice{Un test choisi au hasard}
    \correctchoice{Un ensemble d'entrées prévues, chacune accompagnée de sa sortie attendue, qui couvre les cas typiques et les cas limites de la fonction}
    \wrongchoice{Un manuel d'utilisation du programme}
    \wrongchoice{Une collection de jeux vidéo}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q09}
    \begin{lstlisting}
File "main.py", line 5, in <module>
    print(liste[5])
IndexError: list index out of range
\end{lstlisting}
Que dit cette trace d'erreur ?
    \begin{choices}
    \correctchoice{À la ligne $5$ de \texttt{main.py}, on tente d'accéder à \texttt{liste[5]} alors que cet indice n'existe pas (la liste est trop courte)}
    \wrongchoice{La ligne $5$ contient une variable non définie}
    \wrongchoice{Il s'agit d'une erreur de syntaxe}
    \wrongchoice{Aucun problème n'est signalé}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q10}
    Pour comprendre l'origine d'un bug
dans un programme, quelle démarche
est la plus efficace en première
approche ?
    \begin{choices}
    \wrongchoice{Ignorer le bug s'il n'apparaît qu'à l'occasion}
    \correctchoice{Réduire l'entrée problématique au cas le plus simple qui reproduit encore le bug}
    \wrongchoice{Réécrire l'intégralité du programme depuis zéro}
    \wrongchoice{Multiplier la taille de l'entrée jusqu'à trouver une régularité}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q11}
    Quel module de la bibliothèque
standard de Python permet d'écrire
des \textbf{tests structurés} ?
    \begin{choices}
    \wrongchoice{\texttt{debug}}
    \correctchoice{\texttt{unittest}}
    \wrongchoice{\texttt{assert\_module}}
    \wrongchoice{\texttt{tests}}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q12}
    Pourquoi la bibliothèque \texttt{pytest}
est-elle si populaire ?
    \begin{choices}
    \correctchoice{Pour sa syntaxe simple (un \texttt{assert valeur == attendu} suffit, pas besoin de classes), ses fixtures et son écosystème de greffons}
    \wrongchoice{Parce qu'elle est obligatoire dans tout projet Python}
    \wrongchoice{Parce qu'elle génère automatiquement le code des tests}
    \wrongchoice{Parce qu'elle est plus rapide à l'exécution}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q13}
    \begin{lstlisting}
def somme(liste):
    total = 0
    for i in range(1, len(liste)):
        total += liste[i]
    return total
\end{lstlisting}
Quel \textbf{bug} contient cette fonction ?
    \begin{choices}
    \wrongchoice{Aucun bug n'est présent}
    \wrongchoice{La fonction ne renvoie aucune valeur}
    \wrongchoice{La syntaxe est incorrecte}
    \correctchoice{La boucle commence à l'indice $1$ au lieu de $0$, donc l'élément \texttt{liste[0]} est ignoré}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q14}
    Dans une trace d'erreur à plusieurs
niveaux, où trouve-t-on en général
la \textbf{cause initiale} du bug ?
    \begin{choices}
    \wrongchoice{Au milieu de la trace}
    \wrongchoice{Au hasard dans la trace}
    \wrongchoice{En haut de la trace}
    \correctchoice{La dernière ligne (en bas), qui indique le type et le message d'erreur, et la ligne immédiatement au-dessus, qui pointe l'endroit dans votre code}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q15}
    Pour résoudre un bug, qu'est-ce qui
est \textbf{essentiel} à faire en
premier ?
    \begin{choices}
    \wrongchoice{Demander à un collègue de regarder le code}
    \wrongchoice{Réécrire le code suspect}
    \wrongchoice{Réinstaller l'interpréteur Python}
    \correctchoice{Le reproduire : trouver une entrée minimale qui déclenche systématiquement le bug}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q16}
    Qu'est-ce qu'un \textbf{débogueur} ?
    \begin{choices}
    \wrongchoice{Un compilateur}
    \correctchoice{Un outil qui permet d'exécuter pas à pas, d'inspecter les variables, de poser des points d'arrêt et de remonter la pile des appels}
    \wrongchoice{Un antivirus}
    \wrongchoice{Un fichier de journalisation}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q17}
    Que mesure la \textbf{couverture de
tests} ?
    \begin{choices}
    \correctchoice{La proportion de lignes (ou de branches) du code qui sont effectivement exécutées par les tests}
    \wrongchoice{La taille en octets du programme}
    \wrongchoice{Le nombre total de tests écrits}
    \wrongchoice{La performance d'exécution du programme}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q18}
    Qu'est-ce qu'un \textbf{test de
régression} ?
    \begin{choices}
    \wrongchoice{Un test qui revient en arrière dans le code}
    \wrongchoice{Un test qui échoue à chaque exécution}
    \correctchoice{Un test ajouté après avoir corrigé un bug, dont le rôle est de vérifier que ce bug ne réapparaisse pas dans le futur}
    \wrongchoice{Un test sur l'ancienne version du code}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q19}
    Pourquoi préfère-t-on le module
\texttt{logging} à la fonction \texttt{print}
pour le débogage en production ?
    \begin{choices}
    \wrongchoice{Parce que la fonction \texttt{print} n'existe pas en Python}
    \correctchoice{Pour pouvoir activer ou désactiver les messages, choisir leur niveau de gravité (\texttt{debug}, \texttt{info}, \texttt{warning}, \texttt{error}), les rediriger vers un fichier, etc.}
    \wrongchoice{Parce que le module \texttt{logging} est obligatoire}
    \wrongchoice{Pour gagner de l'espace en mémoire}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q20}
    Quel est l'avantage principal
d'écrire les tests \textbf{avant} le
code (approche dite de
développement piloté par les
tests) ?
    \begin{choices}
    \correctchoice{Elle oblige à clarifier la spécification avant l'implémentation, et garantit que la fonction sera testable et fera bien ce qui est attendu}
    \wrongchoice{Le code est plus rapide à écrire dès le départ}
    \wrongchoice{Elle dispense d'écrire des commentaires}
    \wrongchoice{Elle permet d'éviter complètement les bugs}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q21}
    Un bug se produit \textbf{parfois},
sans que l'on sache prévoir
quand. Que faire ?
    \begin{choices}
    \correctchoice{Multiplier les journaux d'exécution, ajouter des assertions, et étudier ce qui change entre les exécutions où le programme fonctionne et celles où il échoue (synchronisation, ordre, données d'entrée)}
    \wrongchoice{Réinstaller Python}
    \wrongchoice{Acheter un nouvel ordinateur}
    \wrongchoice{Ignorer le bug}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q22}
    Devant un bug, quelle est la
\textbf{bonne stratégie} générale à
adopter ?
    \begin{choices}
    \wrongchoice{Demander une mise à jour du langage Python}
    \correctchoice{Reproduire le bug, isoler la cause (en réduisant l'entrée au cas minimal), corriger, puis ajouter un test de régression}
    \wrongchoice{Réécrire intégralement le programme}
    \wrongchoice{Désactiver les tests existants}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q23}
    Quel est le problème avec ce
test ?
\begin{lstlisting}
assert chercher([1, 2, 3], 2)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{La syntaxe est invalide}
    \wrongchoice{La fonction \texttt{chercher} n'existe pas}
    \wrongchoice{Aucun problème particulier}
    \correctchoice{Il vérifie seulement que \texttt{chercher} renvoie une valeur considérée comme vraie au sens booléen, mais pas que l'indice est correct. La fonction pourrait renvoyer $0$ (qui est le bon indice mais évalue à \texttt{False}) ou $999$ (qui est faux, mais évalue à \texttt{True})}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q24}
    Quelle est la
\textbf{complémentarité} entre tests
et débogage ?
    \begin{choices}
    \wrongchoice{L'une remplace l'autre}
    \correctchoice{Les tests trouvent les bugs (sur les cas testés), le débogage localise et corrige un bug déjà repéré}
    \wrongchoice{Le débogage permet d'éviter d'écrire des tests}
    \wrongchoice{Les deux activités sont identiques}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q25}
    Parmi les affirmations suivantes
sur les tests et le débogage,
laquelle est \textbf{fausse} ?
    \begin{choices}
    \wrongchoice{Réduire l'entrée problématique au cas le plus simple qui reproduit le bug aide à localiser sa cause}
    \wrongchoice{La trace d'erreur indique le type d'erreur et la ligne où elle s'est produite}
    \wrongchoice{Un test unitaire vérifie une seule fonction de manière isolée}
    \correctchoice{Les tests garantissent l'absence de bugs}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q26}
    On distingue habituellement les
erreurs de \textbf{syntaxe}, les
erreurs \textbf{d'exécution} et les
erreurs \textbf{sémantiques} (ou
logiques). Quelle catégorie est
la plus difficile à détecter
automatiquement ?
    \begin{choices}
    \wrongchoice{Les erreurs de syntaxe, car elles cassent toute l'exécution}
    \wrongchoice{Les erreurs d'exécution, car le programme s'arrête en cours de route}
    \correctchoice{Les erreurs sémantiques, car le programme s'exécute sans planter, mais ne fait pas ce qu'il devrait faire}
    \wrongchoice{Les trois catégories sont équivalentes}
    \end{choices}
  \end{question}
}

\element{premieretestsdebogage}{
  \begin{question}{q27}
    Comment écrire un test qui
vérifie le comportement d'une
fonction \texttt{carre} sur \textbf{plusieurs
entrées} sans dupliquer le code
?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def test_carre():
    return carre(0) and carre(1) and carre(3)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def test_carre():
    assert carre(0) == 0
    assert carre(1) == 1
    assert carre(3) == 9
    assert carre(-2) == 4
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def test_carre():
    for x, attendu in [(0, 0), (1, 1), (3, 9), (-2, 4)]:
        assert carre(x) == attendu, f"échec pour x = {x}"
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def test_carre():
    assert carre == 9
\end{lstlisting}
}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{premieretestsdebogage}
  \insertgroup{premieretestsdebogage}
}

\end{document}
