\chapter{Validation et testage de Vampire}
  Nous devons mettre en place un moyen pour savoir si notre
  application fait ce que l'on lui avait ordonné. C'est pourquoi,
  nous devons d'abord défnir ce que notre application doit faire suivant des
  scénarios: on le modélisera à l'aide de \textbf{diagramme de séquence}. On
  doit essayer de mettre dans un diagramme le scénario traçable le plus basique
  possible.
  
  \vspace{15pt}
  
  Un scénario traçable c'est un scénario qui permet de dire suivant un contexte le
  comportement que Vampire a eu, et si le comportement est adapté au contexte. Un
  scénario le plus basique possible c'est un scénario qui a une séquence d'action
  réduite donc facile à tracer et à un contexte subjectif (on enlève les 
  informations qui peuvent complexifier inutilement le comportement).
  
  \section{Les contraintes dans le codes source}
    Comme on l'a dit ci dessus on doit pouvoir tracé le comportement de Vampire
    suivant un contexte, donc on doit d'abord s'assurer de la compréhension du
    contexte par Vampire.
    C'est pourquoi on doit dans chaque classe permettre de sérialiser dans un
    flux l'état d'un objet. Ainsi on pourra créer des textbf{fichiers d'otoptie}
    d'un objet et d'un composant, pour que l'on puisse les parsers et les
    interprétés convenablement ensuite.
    
    \vspace{15pt}
    
    De plus on doit pouvoir tracer le comportement donc suivant un niveau de 
    debogage, on affichera à chaque méthode un message spécifique (suivant ce
    niveau de debogage). L'idéal c'est que ces message soit super explicite et
    formatter pour pouvoir les parsers. On peut même envisager à utiliser un
    format comme \textbf{XML}. Ce style de traçage ressemble beaucoup à un
    style \textbf{Log4J} pour Java.
    
  \section{Des tests spécifiques pour chaques composants de Vampire}
    Il est relativement difficile de proposer une méthode générique pour tester
    Vampire dans son utilisation globale car il englobe beaucoup de 
    fonctionnalité qui doivent en fait être tester séparement.
    
    \vspace{15pt}
    
    Ainsi la validation de Vampire peut être serieusement envisageable si et 
    seulement si tous les composants testés indépendement ont été validé.
    
    \subsection{Validation des parsers de fichiers}
      La première tâche de Vampire est d'avoir un état initial suivant les 
      fichiers qu'il prend en compte lors de son lancement.
      
      \vpsace{15pt}
      
      Pour savoir s'il prend bien en compte ces fichiers (XML) on peut rajouter
      des balises XML de debogage dans ces fichiers pour décrire ce que l'on
      attends qui fasse. Si on lance Vampire en mode debogage de ce composant
      il nous indiquera alors l'état des objets d'initialisation et ce qu'il
      estime devoir faire avec de telles informations. 
      
      \vspace{15pt}
      
      Donc on pourra comparer les fichiers de configurations et les fichiers
      d'\textbf{otoptie de Vampire}. Donc grâce à la balise
      de debogage on peut savoir si il a pris les bonnes premières décisions.
  
    \subsection{L'envoie de commande}
      Pour tester l'envoie de commande on peut copier sur un système de 
      validation communication de communication synchrone. C'est à dire que 
      l'on a un Vampire1 qui envoie une commande à un Vampire2 sur une autre
      \emph{compile farm} et cette commande envoyé c'est un commande pour
      envoyer un message (un signe en faite) à la machine qui à lancer 
      Vampire1. Mais cela suppose tout d'abord que les 2 Vampire possède les
      bons fichiers de configurations. Ainsi on pourra déterminer:
      \begin{itemize}
        \item La validité de notre composant.
        \item Aussi tester les performances de ces transferts.
      \end{itemize}
      
      \vspace{15pt}
      
      On peut répéter ce type test pour tous les protocoles réseaux disponibles
      sur le parc.
    
      \vspace{15pt}
    
      ############################## \\
      ### MAX ZYVA AVEC TA SONDE ### \\
      ############################## \\
      
    \subsection{Transfert de fichier}
    
    \subsection{Exportation de format}
      La validation de ce module ressemble beaucoup à la validation du
      composant d'initialisation. C'est à dire que l'on va comparer les 
      fichiers d'otopsie des objets qui seront utlisés pour l'exportations des
      données avec les données exectivement exporter.
      \begin{itemize}
        \item Les données ont été exporté?
        \item Les données exportées correspondent à l'état final de Vampire.
      \end{itemize}