\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Tests et débogage}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en A
\begin{frame}[fragile]{Question 1 \textemdash{} Notion de test}
    Qu'appelle-t-on un \textbf{test} dans le
contexte du logiciel ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une vérification automatique qu'un programme se comporte comme attendu sur des entrées choisies}
        \item[B.] Un type particulier de variable
        \item[C.] Une question à choix multiple posée à l'utilisateur
        \item[D.] Un avertissement émis par le langage Python
    \end{itemize}
\end{frame}

% Q2 - Réponse en A
\begin{frame}[fragile]{Question 2 \textemdash{} Instruction assert}
    Que fait l'instruction \texttt{assert
condition} en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Si la condition est fausse, elle lève une exception \texttt{AssertionError} ; sinon, elle ne fait rien}
        \item[B.] Elle affiche la condition à l'écran
        \item[C.] Elle convertit la condition en booléen
        \item[D.] Elle ne fonctionne qu'en mode débogage
    \end{itemize}
\end{frame}

% Q3 - Réponse en D
\begin{frame}[fragile]{Question 3 \textemdash{} Test unitaire}
    Qu'est-ce qu'un \textbf{test unitaire} ?\medskip
    \begin{itemize}
        \item[A.] Un test sans coût
        \item[B.] Un test qui couvre tout le programme
        \item[C.] Un test qui dure très longtemps
        \item[\alert<2>{D.}] \alert<2>{Un test qui vérifie le comportement d'une seule fonction (une « unité » de code) sur des entrées spécifiques}
    \end{itemize}
\end{frame}

% Q4 - Réponse en B
\begin{frame}[fragile]{Question 4 \textemdash{} Exemple de test}
    Quelle ligne \textbf{teste} que \texttt{carre(3)
== 9} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{if carre(3) != 9: print("erreur")}
        \item[\alert<2>{B.}] \alert<2>{\texttt{assert carre(3) == 9}}
        \item[C.] \texttt{carre(3)}
        \item[D.] \texttt{test carre(3) == 9}
    \end{itemize}
\end{frame}

% Q5 - Réponse en D
\begin{frame}[fragile]{Question 5 \textemdash{} Erreur Python}
    Quand Python lève une \textbf{erreur}, où
regarder pour comprendre ce qui se
passe ?\medskip
    \begin{itemize}
        \item[A.] Le code source du module Python lui-même
        \item[B.] Les paramètres du système d'exploitation
        \item[C.] Sur Internet, en cherchant un message proche
        \item[\alert<2>{D.}] \alert<2>{La trace d'erreur affichée par Python, qui indique le fichier, la ligne concernée et le type d'erreur}
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile]{Question 6 \textemdash{} Instruction print de débogage}
    À quoi sert un appel à \texttt{print} dans
un objectif de \textbf{débogage} ?\medskip
    \begin{itemize}
        \item[A.] À empêcher d'écrire d'autres lignes de code
        \item[B.] À encoder des données en hexadécimal
        \item[\alert<2>{C.}] \alert<2>{À afficher la valeur d'une variable à un moment précis du programme, pour suivre son déroulement}
        \item[D.] À ralentir intentionnellement le programme
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} Notion de bug}
    Qu'est-ce qu'un \textbf{bug} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une erreur ou un comportement non conforme aux spécifications du programme}
        \item[B.] Une fonctionnalité que l'utilisateur n'a pas demandée
        \item[C.] Une nouvelle version d'un logiciel
        \item[D.] Un type particulier de mémoire
    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Jeu d'essais}
    Qu'est-ce qu'un \textbf{jeu d'essais} ?\medskip
    \begin{itemize}
        \item[A.] Un test choisi au hasard
        \item[\alert<2>{B.}] \alert<2>{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}
        \item[C.] Un manuel d'utilisation du programme
        \item[D.] Une collection de jeux vidéo
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 9 \textemdash{} Lire une trace d'erreur}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] À 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)
        \item[B.] La ligne $5$ contient une variable non définie
        \item[C.] Il s'agit d'une erreur de syntaxe
        \item[D.] Aucun problème n'est signalé
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 9 \textemdash{} Lire une trace d'erreur}
    \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 ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{À 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)}
        \item[B.] La ligne $5$ contient une variable non définie
        \item[C.] Il s'agit d'une erreur de syntaxe
        \item[D.] Aucun problème n'est signalé
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile]{Question 10 \textemdash{} Isoler un bug}
    Pour comprendre l'origine d'un bug
dans un programme, quelle démarche
est la plus efficace en première
approche ?\medskip
    \begin{itemize}
        \item[A.] Ignorer le bug s'il n'apparaît qu'à l'occasion
        \item[\alert<2>{B.}] \alert<2>{Réduire l'entrée problématique au cas le plus simple qui reproduit encore le bug}
        \item[C.] Réécrire l'intégralité du programme depuis zéro
        \item[D.] Multiplier la taille de l'entrée jusqu'à trouver une régularité
    \end{itemize}
\end{frame}

% Q11 - Réponse en B
\begin{frame}[fragile]{Question 11 \textemdash{} Module unittest}
    Quel module de la bibliothèque
standard de Python permet d'écrire
des \textbf{tests structurés} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{debug}
        \item[\alert<2>{B.}] \alert<2>{\texttt{unittest}}
        \item[C.] \texttt{assert\_module}
        \item[D.] \texttt{tests}
    \end{itemize}
\end{frame}

% Q12 - Réponse en A
\begin{frame}[fragile]{Question 12 \textemdash{} La bibliothèque pytest}
    Pourquoi la bibliothèque \texttt{pytest}
est-elle si populaire ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour sa syntaxe simple (un \texttt{assert valeur == attendu} suffit, pas besoin de classes), ses fixtures et son écosystème de greffons}
        \item[B.] Parce qu'elle est obligatoire dans tout projet Python
        \item[C.] Parce qu'elle génère automatiquement le code des tests
        \item[D.] Parce qu'elle est plus rapide à l'exécution
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Identifier un bug}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Aucun bug n'est présent
        \item[B.] La fonction ne renvoie aucune valeur
        \item[C.] La syntaxe est incorrecte
        \item[D.] La boucle commence à l'indice $1$ au lieu de $0$, donc l'élément \texttt{liste[0]} est ignoré
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Identifier un bug}
    \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 ?\medskip
    \begin{itemize}
        \item[A.] Aucun bug n'est présent
        \item[B.] La fonction ne renvoie aucune valeur
        \item[C.] La syntaxe est incorrecte
        \item[\alert{D.}] \alert{La boucle commence à l'indice $1$ au lieu de $0$, donc l'élément \texttt{liste[0]} est ignoré}
    \end{itemize}
\end{frame}

% Q14 - Réponse en D
\begin{frame}[fragile]{Question 14 \textemdash{} Lire la trace d'erreur}
    Dans une trace d'erreur à plusieurs
niveaux, où trouve-t-on en général
la \textbf{cause initiale} du bug ?\medskip
    \begin{itemize}
        \item[A.] Au milieu de la trace
        \item[B.] Au hasard dans la trace
        \item[C.] En haut de la trace
        \item[\alert<2>{D.}] \alert<2>{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{itemize}
\end{frame}

% Q15 - Réponse en D
\begin{frame}[fragile]{Question 15 \textemdash{} Reproduire un bug}
    Pour résoudre un bug, qu'est-ce qui
est \textbf{essentiel} à faire en
premier ?\medskip
    \begin{itemize}
        \item[A.] Demander à un collègue de regarder le code
        \item[B.] Réécrire le code suspect
        \item[C.] Réinstaller l'interpréteur Python
        \item[\alert<2>{D.}] \alert<2>{Le reproduire : trouver une entrée minimale qui déclenche systématiquement le bug}
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} Débogueur}
    Qu'est-ce qu'un \textbf{débogueur} ?\medskip
    \begin{itemize}
        \item[A.] Un compilateur
        \item[\alert<2>{B.}] \alert<2>{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}
        \item[C.] Un antivirus
        \item[D.] Un fichier de journalisation
    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile]{Question 17 \textemdash{} Couverture de tests}
    Que mesure la \textbf{couverture de
tests} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La proportion de lignes (ou de branches) du code qui sont effectivement exécutées par les tests}
        \item[B.] La taille en octets du programme
        \item[C.] Le nombre total de tests écrits
        \item[D.] La performance d'exécution du programme
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile]{Question 18 \textemdash{} Test de régression}
    Qu'est-ce qu'un \textbf{test de
régression} ?\medskip
    \begin{itemize}
        \item[A.] Un test qui revient en arrière dans le code
        \item[B.] Un test qui échoue à chaque exécution
        \item[\alert<2>{C.}] \alert<2>{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}
        \item[D.] Un test sur l'ancienne version du code
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile]{Question 19 \textemdash{} Module logging}
    Pourquoi préfère-t-on le module
\texttt{logging} à la fonction \texttt{print}
pour le débogage en production ?\medskip
    \begin{itemize}
        \item[A.] Parce que la fonction \texttt{print} n'existe pas en Python
        \item[\alert<2>{B.}] \alert<2>{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.}
        \item[C.] Parce que le module \texttt{logging} est obligatoire
        \item[D.] Pour gagner de l'espace en mémoire
    \end{itemize}
\end{frame}

% Q20 - Réponse en A
\begin{frame}[fragile]{Question 20 \textemdash{} Écrire les tests avant le code}
    Quel est l'avantage principal
d'écrire les tests \textbf{avant} le
code (approche dite de
développement piloté par les
tests) ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Elle oblige à clarifier la spécification avant l'implémentation, et garantit que la fonction sera testable et fera bien ce qui est attendu}
        \item[B.] Le code est plus rapide à écrire dès le départ
        \item[C.] Elle dispense d'écrire des commentaires
        \item[D.] Elle permet d'éviter complètement les bugs
    \end{itemize}
\end{frame}

% Q21 - Réponse en A
\begin{frame}[fragile]{Question 21 \textemdash{} Bug intermittent}
    Un bug se produit \textbf{parfois},
sans que l'on sache prévoir
quand. Que faire ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{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)}
        \item[B.] Réinstaller Python
        \item[C.] Acheter un nouvel ordinateur
        \item[D.] Ignorer le bug
    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile]{Question 22 \textemdash{} Stratégie globale}
    Devant un bug, quelle est la
\textbf{bonne stratégie} générale à
adopter ?\medskip
    \begin{itemize}
        \item[A.] Demander une mise à jour du langage Python
        \item[\alert<2>{B.}] \alert<2>{Reproduire le bug, isoler la cause (en réduisant l'entrée au cas minimal), corriger, puis ajouter un test de régression}
        \item[C.] Réécrire intégralement le programme
        \item[D.] Désactiver les tests existants
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Test mal écrit}
    Quel est le problème avec ce
test ?
\begin{lstlisting}
assert chercher([1, 2, 3], 2)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] La syntaxe est invalide
        \item[B.] La fonction \texttt{chercher} n'existe pas
        \item[C.] Aucun problème particulier
        \item[D.] 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{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Test mal écrit}
    Quel est le problème avec ce
test ?
\begin{lstlisting}
assert chercher([1, 2, 3], 2)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] La syntaxe est invalide
        \item[B.] La fonction \texttt{chercher} n'existe pas
        \item[C.] Aucun problème particulier
        \item[\alert{D.}] \alert{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{itemize}
\end{frame}

% Q24 - Réponse en B
\begin{frame}[fragile]{Question 24 \textemdash{} Tests et débogage}
    Quelle est la
\textbf{complémentarité} entre tests
et débogage ?\medskip
    \begin{itemize}
        \item[A.] L'une remplace l'autre
        \item[\alert<2>{B.}] \alert<2>{Les tests trouvent les bugs (sur les cas testés), le débogage localise et corrige un bug déjà repéré}
        \item[C.] Le débogage permet d'éviter d'écrire des tests
        \item[D.] Les deux activités sont identiques
    \end{itemize}
\end{frame}

% Q25 - Réponse en D
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes
sur les tests et le débogage,
laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] Réduire l'entrée problématique au cas le plus simple qui reproduit le bug aide à localiser sa cause
        \item[B.] La trace d'erreur indique le type d'erreur et la ligne où elle s'est produite
        \item[C.] Un test unitaire vérifie une seule fonction de manière isolée
        \item[\alert<2>{D.}] \alert<2>{Les tests garantissent l'absence de bugs}
    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile]{Question 26 \textemdash{} Trois familles d'erreurs}
    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 ?\medskip
    \begin{itemize}
        \item[A.] Les erreurs de syntaxe, car elles cassent toute l'exécution
        \item[B.] Les erreurs d'exécution, car le programme s'arrête en cours de route
        \item[\alert<2>{C.}] \alert<2>{Les erreurs sémantiques, car le programme s'exécute sans planter, mais ne fait pas ce qu'il devrait faire}
        \item[D.] Les trois catégories sont équivalentes
    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Plusieurs cas dans un test}
    Comment écrire un test qui
vérifie le comportement d'une
fonction \texttt{carre} sur \textbf{plusieurs
entrées} sans dupliquer le code
?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def test_carre():
    return carre(0) and carre(1) and carre(3)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def test_carre():
    assert carre(0) == 0
    assert carre(1) == 1
    assert carre(3) == 9
    assert carre(-2) == 4
\end{lstlisting}

        \item[C.]~\\
\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}

        \item[D.]~\\
\begin{lstlisting}
def test_carre():
    assert carre == 9
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Plusieurs cas dans un test}
    Comment écrire un test qui
vérifie le comportement d'une
fonction \texttt{carre} sur \textbf{plusieurs
entrées} sans dupliquer le code
?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def test_carre():
    return carre(0) and carre(1) and carre(3)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def test_carre():
    assert carre(0) == 0
    assert carre(1) == 1
    assert carre(3) == 9
    assert carre(-2) == 4
\end{lstlisting}

        \item[\alert{C.}]~\\
\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}

        \item[D.]~\\
\begin{lstlisting}
def test_carre():
    assert carre == 9
\end{lstlisting}

    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
