1   Tests Structurels

• les cartes par ordre croissant vont du 2 au 10 puis Valet, Dame, Roi et As (les couleurs ne comptent pas)
• chaque joueur tire 2 cartes
• le joueur ayant la paire la plus forte gagne
• si aucun des joueurs n'a de paire, celui qui a la carte la plus forte gagne.

  
    void Determine_Gagnant(CA1, CA2, CB1, CB2, Gagnant);
    carte_T CA1, CA2;        /* cartes du joueur A */
    carte_T CB1, CB2;        /* cartes du joueur B */
    gagnant_T * Gagnant;     /* Nom du gagnant */
    
      bool Paire_A;
      bool Paire_B = False;

      /* Determiner si joueur A a une paire */
      if ( CA1 == CA2 )                                /* C1 */
        Paire_A = True;
      else
        Paire_A = False;

      /* Determiner si joueur B a une paire */
      if ( CB1 == CB2)                                 /* C2 */
        Paire_B = True;

      /* Le gagnant a la meilleure des paires */
      if ( Paire_A )                                  /* C3 */
        if ( Paire_B )                                /* C4 */
          if ( CA1 > CB1 )                             /* C5 */
            *Gagnant = Joueur_A;
          else
            if ( CA1 < CB1 )                           /* C6 */
              *Gagnant = Joueur_B;
            else
              *Gagnant = Egalite;
        
        else
          *Gagnant = Joueur_A;
      
      else 
        if ( Paire_B )                                 /* C7 */
          *Gagnant = Joueur_B;
        else 
          /* Aucun des joueurs n'a de paire */
          Meilleure_A = CA2;
          Meilleure_B = CB2;

          if ( CA1 > CA2 )                             /* C8 */
            Meilleure_A = CA1;
          
          if ( CB1 > CB2 )                             /* C9 */
            Meilleure_B = CB1;

          if ( Meilleure_A > Meilleure_B )             /* C10 */
            *Gagnant = Joueur_A;
          else
            if ( Meilleure_B > Meilleure_A )           /* C11 */
              *Gagnant = Joueur_B;
            else
              *Gagnant = Egalite;
        
    

1. Déterminer les entrées et sorties du programme;
2. Dessiner le graphe de contrôle de programme (organigramme);
3. Déterminer les jeux de tests pour obtenir la couverture des instructions du programme;
4. Déterminer les jeux de tests pour obtenir la couverture des chemins du programme.

• si la tension lue est hors des bornes fonctionnelles [0..TENSION_MAX], le capteur est déclaré invalide
• lorsque la tension est entre ses bornes fonctionnelles, si
  |tension lue - tension cycle précédent| > DELTA_MAX
  pendant 2 cycles consécutifs, alors le capteur n'est plus valide. Pendant ce filtrage, la tension filtrée reste à la valeur précédente et le capteur reste valide
• dans tous les autres cas, le capteur est déclaré valide et la tension filtrée est égale à la tension lue.

    #define TENSION_MAX     380;
    #define DELTA_MAX        40;
    #define FILTRE_MAX        2;

    int_16 tension_pre;
    int_16 filtre = 0;

    void filtrage_entrees (tension_lue, tension_filtree, validite_capteur);
    int_16 tension_lue;
    int_16 *tension_filtree;
    bool *validite_capteur;
    
      /* Verification de la gamme de la tension lue */
      if (( tension_lue < 0 ) || (tension_lue > TENSION_MAX))   /* C1 */
        /* capteur HS */
        *validite_capteur = False;
      else
        /* Coherence tension lue */
        if (( tension_lue - tension_pre <= DELTA_MAX) ||        /* C2 */
           ( tension_pre - tension_lue >= DELTA_MAX)) 
           /* Tension lue incoherente */
          if ( filtre >= FILTRE_MAX )                          /* C3 */
            /* Filtrage maximum atteint */
            *validite_capteur = False;
          
          else 
            *validite_capteur = True;
            *tension_filtree = tension_pre;
            /* Increment du filtrage */
            filtre = filtre + 1;
          
        
        else 
          /* Initialisation des sorties */
          tension_filtree = tension_lue;
          *validite_capteur = True;
          *tension_pre = tension_lue

          /* Reset du filtrage */
          filtre = 0;
        
    

1. Déterminer les entrées et sorties du programme;
2. Déterminer les jeux de tests pour obtenir la couverture des données aux limites du programme;
3. Déterminer les jeux de tests pour obtenir la couverture des données hors limites du programme.

2   Tests Fonctionnels

    CAL(1)            Manuel de l'utilisateur Linux            CAL(1)


    NOM
           cal - Afficher un calendrier.

    SYNOPSIS
           cal [-mjy] [[mois] [annee]]

    DESCRIPTION
           Cal affiche un calendrier.  Si les arguments sont omis, le
           mois courant  est  affiché  sauf  pour  l'option  -y.  Les
           options sont les suivantes:

           -m     Affiche le calendrier en considérant lundi comme le
           premier jour de la semaine (Dimanche par défaut.) 

           -j     Affiche  les  numéros  des  jours  dans l'année (le
                  numéro 1 correspond au 1er Janvier).

           -y     Affiche le calendrier de l'année courante.

           Un paramètre unique indique l'année (1 - 9999) à afficher;
           noter que l'année doit être complètement spécifiée : ``cal
           89'' n'affiche pas le calendrier de 1989.  Deux paramètres
           indiquent  le mois (1 - 12) et l'année.  S'il n'y a pas de
           paramètres, le calendrier du mois courant est affiché.

           L'année commence le 1er Janvier.

    HISTORIQUE
           La commande cal est apparue dans  la  version  6  de  AT&T
           UNIX.


    TRADUCTION
           Michel Quercia, 1997.

1. Déterminer les entrées et sorties de la commande;
2. Déterminer les jeux de tests pour obtenir la couverture nominale de la commande;
3. Déterminer les jeux de tests pour obtenir la couverture aux limites de la commande lorsqu'il n'y a pas d'option;
4. Déterminer les jeux de tests pour obtenir la couverture hors limites de la commande lorsqu'il n'y a pas d'option.

• options : -j, -m, -y
• paramètres : jour, année

Ce document a été traduit de L^AT_EX par H^EV^EA.