---
# System prepended metadata

title: Tableau des cas de tests
tags: [specs]

---

# Tableau des cas de tests

###### tags: `specs`
:
#### Glossaire
**- Graphe G0**

```mermaid
graph LR 
1 -->|1 arc1| 2
0 -->|1 arc2| 1
0 -->|1 arc3| 2
1 -->|1 arc5| 3
2 -->|1 arc6| 3
2 -->|1 arc7| 5
3 -->|1 arc8| 4
```
```
eiquette = "Graphe0"
list_arc =<arc1,arc2,arc3,arc4,arc5,arc6,arc7,arc8>
list sommet = <0,1,2,5,3,4> 	
string path  = "path0"
```

**- sous-graphe G0'**
```mermaid
graph LR 
1 -->|1 arc1| 2
0 -->|1 arc2| 1
0 -->|1 arc3| 2
1 -->|1 arc5| 3

```
```
eiquette = "Graphe0'"
list_arc =<arc1,arc2,arc3,arc5>
list sommet = <0,1,2,3> 	
string path  = "path0'"
```
        
**- Matrice MA0**
```
   0 1 2 3 4 5
0| 0 1 1 0 0 0
1| 0 0 1 1 0 0
2| 0 0 1 0 0 1
3| 0 0 0 0 1 0
4| 0 0 0 0 0 0
5| 0 0 0 0 0 0

taille_V = 5
taille_E = NULL (?)
type = 0

```

**- Graphe G1**
```mermaid
graph LR 
0 -->|1 arc1| 1
1 -->|1 arc2| 2
2 -->|1 arc3| 0
```
```
eiquette = "Graphe1"
list_arc =<arc1,arc2,arc3>
list sommet = <0,1,2> 	
string path  = NULL
```
**- Matrice Adjacence de G1 MA1**
```
tab = 
  0 1 2        taille_V = 3
0|0 1 0        taille_E = ?
1|0 0 1        type = 0
2|1 0 0
```

**-Matrice Adjacence inverse de G1 MAI1**
```
tab = 
  0 1 2        taille_V = 3
0|0 0 1        taille_E = ?
1|1 0 0        type = 0
2|0 1 0
```

**-Matrice Incidence de G1 MI1**
```
tab = 
    0  1  2     taille_V = 3
0|  1  0 -1     taille_E = 3
1| -1  1  0     type = 1
2|  0 -1  1
```
**- Matrice quelconque MQ**
```
tab = 
  0 1 2        taille_V = 3
0|0 1 0        taille_E = 3
1|0 0 1        type = 4
2|1 0 0
```

**- Matrice quelconque MQ'**
```
tab = 
  0 1 2        taille_V = 3
0|0 1 10        taille_E = 3
1|0 0 1        type = 4
2|1 0 0
```
**- Matrice quelconque MQ''**
```
tab = 
  0 1 2        taille_V = 3
0|0 1 0        taille_E = 3        type = 4
1|1 0 0
```
**- Matrice quelconque MQ'''**
```
tab = 
  0 1        taille_V = 3
0|0 0        taille_E = 3
1|0 1        type = 4
2|1 0
```
**- Pair de matrices PM0**
```
Matrice de poids      Matrice Parent
  0 1 2 3 4 5          0 1 2 3 4 5 
0|0 1 1 2 3 2|       0|0 1 2 1 1 2| 
1|0 0 1 1 2 2|       1|0 0 2 3 3 2|
2|0 0 0 1 2 1|       2|0 0 0 3 3 5| 
3|0 0 0 0 1 0|       3|0 0 0 0 4 0| 
4|0 0 0 0 0 0|       4|0 0 0 0 0 0|
5|0 0 0 0 0 0|       5|0 0 0 0 0 0|

Taille_V = 5         Taille_V = 5
Taille_E = NULL      Taille_E = NULL
type = 2             type = 3
```

**- Matrice M0**
```
  0 1 2
0|0 1 1
1|0 0 0
2|0 0 0
```


**- Matrice M1**
```
  0 1 2
0|0 0 0
1|1 0 0
2|1 0 0
```

**- Matrice M2**
```
  0 1 2
0|0 0 0
1|1 0 0
2|0 0 0
```

**- Matrice M3**
```
   0  1 2  3  4 5  6  7
0| 0 30 1  0  0 0  2  0
1| 0  0 8 11 13 0  0  0
2| 0  0 0 26  0 0  0  0
3| 0  0 0  0  9 8 22  0
4| 0  0 2  0  0 1  0  7
5| 0  0 0  0  0 0  0  7
6| 0  0 0  0  0 0  0 27
7| 0  0 0  0  0 0  0  0
(gestion de flots)
```

**-Graphe G2**
```mermaid
graph LR 

Depart_0.0 --> |1_5| 1_5.5
Depart_0.0 --> |2_1| 2_1.6
Depart_0.0 --> |3_7| 3_7.8
1_5.5 -.-> |0| 3_7.8
2_1.6 --> |4_3| 4_5.9
1_5.5 -.-> |0| 4_5.9
3_7.8 --> |7_4| 6.7.9_12.12
4_5.9 --> |6_3| 6.7.9_12.12
1_5.5 --> |8_4| 8_9.9
8_9.9 --> |9_3| 6.7.9_12.12
8_9.9 --> |11_3| 11-12.15
1_5.5 --> |5_5| 5.10.12_17.17
11-12.15 --> |12_2| 5.10.12_17.17
6.7.9_12.12 --> |10_5| 5.10.12_17.17
```
**-Sommet S0**
etiquette = "sommet0"
id = 0
x = 23
y = 32
vecArc = <A1, A2>
Scharge_utile = <plus_tot,12><plus_tard,12>

**-Sommet S0'**
etiquette = "sommet0'"
id = 12
x = 54
y = 45
vecArc = <A3, A4>
Scharge_utile = <"couleur",1>

**- Sommet S1**
etiquette  =  "sommet1"
id = 1
x = 2
y = 3
vecArc = <A1, A2>

**- Sommet S2**
etiquette  =  "sommet2"
id = 2
x = 2
y = 3

**- Sommet S3**
etiquette  =  "sommet3"
id = 3
x = NULL
y = NULL

**- Sommet S4**
etiquette = NULL
id = 4
x = NULL
y = NULL

**- Sommet S5 Copie constructeur** 
Sommet5 = Sommet2

etiquette = "sommet2"
id = 2
x = 2
y = 3


**- Arc A1**
 etiquette = "arc1"
 id = 1
 Sdepart = 2
 Sarrivee = 3
ACharge_utile = < "flot", 12 >

**- Arc A2**
 etiquette = "arc2"
 id = 4
 Sdepart = 2
 Sarrivee = 4
 ACharge_utile = NULL

**- Arc A3 Copie constructeur**
Arc3 = Arc2

etiquette = "arc2"
id = 4
Sdepart = 2
Sarrivee = 4
ACharge_utile = NULL


**- Arc A4**
 etiquette = 4
 id = 4
 Sdepart = 1
 Sarrivee = 3
 ACharge_utile = NULL
 
**- Arc A5**
 etiquette = 5
 id = 5
 Sdepart = <0,0>
 Sarrivee = <2,2>
 ACharge_utile = NULL
 
**- Fichier graphe0.json**
path = "path0"

**- Fichier test.json**
path = "pathTest"

**- Fichier graphe.txt**


**- onglet O1 **
affiche et contient G0

**- onglet O2 **
affiche et contient G1

**- QSommet QS0 **
id = 0
posx = 23
posy = 32
rayon = 5
coul = "white"
select = false

**- QArc QA0 **
id = 0
posxA = 0
posyA = 0
posxB = 2
posyB = 2


### Gestion de graphe

| Déclaration du test                             | Cas de test                                                                                                  | Retour attendu                                                                                  |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
| TEST_CASE("Test de l'operateur ==", "[Sommet]") | Sommet S0; Sommet S1                                                                                         | true; false                                                                                     |
| TEST_CASE("Test de l'operateur =", "[Sommet]")  | Sommet 2                                                                                                     | Sommet 5                                                                                        |
| TEST_CASE("test des constructeurs", "[Sommet]") | Sommet1("sommet1", 1,2,3,vec); Sommet2("sommet2", 2,2,3); Sommet3("sommet3",3); Sommet4(4); Sommet5(Sommet4) | Sommet S1; Sommet S2; Sommet S3; Sommet S4; Sommet S5                                           |
| TEST_CASE("test du destructeur", "[Sommet]")    | Sommet S1                                                                                                    | NULL                                                                                            |
| TEST_CASE("test des getters", "[Sommet]")       | Sommet S0                                                                                                    | "sommet0"; 0; 23; 32; <A1,A2>; 12                                                               |
| TEST_CASE("test des setters", "[Sommet]")       | Sommet So, sommet0', 12, 54, 45, <A3, A4>, <couleur,1>                                                       | etiquette = "sommet0'"; id = 12; x = 54; y = 45; vecArc = <A3, A4>; Scharge_utile = <couleur,1> |



| TEST_CASE ("Test de l'operateur =", "[arc]")  | Arc A2                                                          | Arc A3                         |
| --------------------------------------------- | --------------------------------------------------------------- | ------------------------------ |
| TEST_CASE ("Test de l'operateur ==", "[arc]") | Arc A2; Arc A4                                                  | True; False                    |
| TEST_CASE("test des constructeurs", "[Arc]")  | Arc("A1",1,2,3,<flot,12>); Arc("A2",1,2,4); Arc(4,1,3); Arc(A2) | Arc A1; Arc A2; Arc A4; Arc A3 |
| TEST_CASE("test du destructeur", "[Arc]")     | Arc A1                                                          | NULL                           |
| TEST_CASE("test des getters", "[Arc]")        | Arc A1                                                          | "arc1"; 1; 2; 3; <flot, 12>.   |
| TEST_CASE("test des setters", "[Arc]")        | Arc A1, "modif", 37, 7, 44                                      | "modif"; 37; 7; 44.            |


| TEST_CASE ("Test de l'operateur =", "[graphe]")                                 | Graphe G1                                                            | Graphe G1'                                                  |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------- |
| TEST_CASE ("Test de l'operateur ==", "[graphe]")                                | Graphe G1, Graphe G1'                                                | true; false                                                 |
| TEST_CASE("test des constructeurs", "[graphe]")                                 | graphe("G0",5, <>, <>,""); graphe(G0); graphe("G2"); graphe(M1);     | graphe G0; graphe G1; graphe G2; graphe G3;                 |
| TEST_CASE("test du destructeur", "[graphe]")                                    | delete G1                                                            | NULL                                                        |
| TEST_CASE("test des getters", "[graphe]")                                       | G1.get_etiquette(): G1.get_listeArc(); G1.get_listeSommet();         | "graphe1"; <arc1, arc2, arc3>; <sommet0, sommet1, sommet2>. |
| TEST_CASE("test des setters", "[graphe]")                                       | G1.set_etiquette("modif"): G1.set_listeArc(<arc1,arc2, arc3, arc4>); | "modif"; <arc1,arc2,arc3,arc4>                              |
| TEST_CASE("Test des conversions en matrice d'incidence + adjacence","[graphe]") | Graphe G1                                                            | Matrice MA1; MI1                                            |
| TEST_CASE("Test d'ajout de sommet","[graphe]")                                  | Sommet S4                                                            | 4                                                           |
| TEST_CASE("Test suppression de sommet","[graphe]")                              | Sommet S4                                                            | 4                                                           |
| TEST_CASE("Test d'ajout d'arc","[graphe]")                                      | Arc A4                                                               | 4                                                           |
| TEST_CASE("Test suppression d'arc","[graphe]")                                  | Arc A4                                                               | 4                                                           |
| TEST_CASE("Test de la conversion en liste de voisins","[graphe]")               | Graphe G0                                                            | <<1,2><2,3><3,5><4><><>>                                    |


|                                                                             |                                                         |                                               |
| --------------------------------------------------------------------------- | ------------------------------------------------------- | --------------------------------------------- |
| TEST_CASE ("Test de l'operateur =", "[Matrice]")                            | Matrice M0                                              | Matrice M0'                                   |
| TEST_CASE ("Test de l'operateur ==", "[Matrice]")                           | Matrice M0, Matrice M0'                                 | true; false                                   |
| TEST_CASE("test des constructeurs", "[matrice]")                            | Matrice(G1,3); Matrice(3,3,3); Matrice(1); Matrice (M1) | Matrice MA1; Matrice MI1; M1; M2;             |
| TEST_CASE("test du destructeur", "[matrice]")                               | Matrice M1                                              | NULL                                          |
| TEST_CASE("test des getters", "[matrice]")                                  | Matrice  MI1                                            | taille_V = 3, taille_E = 3, type = 1, MI1.tab |
| TEST_CASE("test de conversion en matrice d'incidence","[matrice]")          | Matrice MA1                                             | Matrice MI1                                   |
| TEST_CASE("test d'erreur de conversion en matrice d'incidence","[matrice]") | Matrice MQ                                              | -1                                            |
| TEST_CASE("test d'inversion de la matrice","[matrice]")                     | Matrice MA1                                             | Matrice MAI1                                  |
| TEST_CASE("test de la conversion en graphe","[matrice]")                    | Matrice MA1, Matrice MI1                                | Graphe G1'                                    |
| TEST_CASE("test d'erreur de la conversion en graphe","[matrice]")           | MQ                                                      | -1                                            |
| TEST_CASE("test de sommet isolé d'un graphe","[matrice]")                   | Matrice MA1; Matrice M2                                 | 1; 0                                          |
| TEST_CASE("test modification d'une case","[matrice]")                       | MQ.modifTab(1,2,10)                                     | MQ'                                           |
| TEST_CASE("test suppression ligne","[matrice]")                             | MQ.supprLigne(1)                                        | MQ''                                          |
| TEST_CASE("test suppression colonne","[matrice]")                           | MQ.supprCol(1)                                          | MQ'''                                         |



### Opérations sur les graphes

| Déclaration du test                                        |                                                                                                Cas de test                                                                                                 | Retour attendu                                                                  |
| ---------------------------------------------------------- |:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:| ------------------------------------------------------------------------------- |
| TEST_CASE("Test de Bellman ", "[]")                        |                                                                                                     M0                                                                                                     | <<<0>, <0,1>, <0, 2>, <0, 1, 3>,  <0, 1, 3, 4>, <0, 2, 5>>, <0, 1, 1, 2, 3, 2>> |
| TEST_CASE("test de Floyd_Warshall", "[]")                  |                                                                                                     M0                                                                                                     | PM0                                                                             |
| TEST-CASE("test des degres d'un sommet", "[]")             |                                                                                           Matrice MA1, sommet 1                                                                                            | <1,1>                                                                           |
| TEST_CASE("test coloration", "[]")                         |                                                                                                     M0                                                                                                     | <0, 1, 1>                                                                       |
| TEST_CASE("test des stables", "[]")                        |                                                                                                    MA1                                                                                                     | < <0,4,5>, <1,5,4>, <0,3,5>, <2,4> >                                            |
| TEST_CASE("test des cliques", "[]")                        |                                                                                                    MA1                                                                                                     | <NULL>                                                                          |
| TEST_CASE("test des voisins", "[]")                        |                                                                                             Matrice MA0, int 1                                                                                             | <2,3>                                                                           |
| TEST_CASE("test de la gestion de flots", "[]")             |                                                                                       Matrice M3, sommet 0, sommet 7                                                                                       | 32                                                                              |
| TEST_CASE("test de l'ordonnancement", "[]")                | <{1,"",5,<>,<>>},{2,"",1,<>,<>},{3,"",7,<>,<>},{4,"",3,<2>,<>},{5,"",5,<1><>},{6,"",3,<1,4>,<>},{7,"",4,<1,3>,<>},{8,"",4,<1>,<>},{9,"",3,<8>,<>},{10,"",5,<6,7,9>,<>},{11,"",3,<8>,<>},{12,"",2,<11>,<>}> | graphe G2                                                                       |
| TEST_CASE("test de l'arborescence", "[]")                  |                                                                                                 Matrice M0                                                                                                 | graphe G'                                                                       |
| TEST_CASE("test de l'anti-arborescence", "[]")             |                                                                                                 Matrice M1                                                                                                 | graphe G'                                                                       |
| TEST_CASE("test detection erreur arborescence", "[]")      |                                                                                           Matrice M1; Matrice M2                                                                                           | Graphe avec -1 sommets                                                          |
| TEST_CASE("test detection erreur anti-arborescence", "[]") |                                                                                           Matrice M0; Matrice M2                                                                                           | Graphe avec -1 sommets                                                          |
| TEST_CASE("test de la connexite", "[]")                    |                                                                                                     M0                                                                                                     | int connexite = 1                                                               |
| TEST_CASE("test des chaines ", "[]")                       |                                                                                                     G1                                                                                                     | <<0,1,2><0,1,2,0>>                                                              |
| TEST_CASE("test detection erreur des chaines ", "[]")      |                                                                                                     G0                                                                                                     | <>                                                                              |
| TEST_CASE("test du postier chinois", "[]")                 |                                                                                                    MA1                                                                                                     | <0,1,2>                                                                         |
| TEST_CASE("test du voyageur de commerce", "[]")            |                                                                                            Matrice MA1, <0,1,2>                                                                                            | <0,1,2>                                                                         |


### Gestion de fichier

| Déclaration du test                               |              Cas de test              | Retour attendu      |
| ------------------------------------------------- |:-------------------------------------:| ------------------- |
| TEST_CASE("test du nom de fichier", "[graphe]")   |                  G0                   | 1                   |
| TEST_CASE("test du chemin du fichier","[graphe]") |                  G0                   | path = G0.path      |
| TEST_CASE("test suppression fichier","[]")        |             graphe0.json              | 1                   |
|          TEST_CASE("Test de validité du fichier", "[]")                                         | path graphe0.json                                      |                   Graphe 0  |
| TEST_CASE("test de validité du fichier", "[]")    | graphe0.json;  test.json;  graphe.txt | true; false; false. |

### Interface graphique

| Déclaration du test                |                         Cas de test                          | Retour attendu                                               |
| ---------------------------------- | :----------------------------------------------------------: | ------------------------------------------------------------ |
| ############################       |                      classe Mainwindow                       | ##################                                            |
| testMainWindow()                   |                             N/A                              | 1                                                            |
| testDestructeur()                  |                             N/A                              | 0                                                            |
| testprintConsole()                 |                        "Hello World"                         | affichage de "Hello World" sur la console                    |
| testprintCaraSelection()           |                          Sommet S0                           | affichage de "sommet0", "0", "23,32"                         |
| testajouterOnglet()                |                             N/A                              | affichage de "Hello World" sur la console                    |
| testsupprimerOnglet()              |                             N/A                              | 1                                                            |

| testChangeOnglet()                 |                            O1,O2                             | "graphe_courant" passe bien de G0 a G1 lorsque on passe de O1 a O2 |
| ---------------------------------- | :----------------------------------------------------------: | ------------------------------------------------------------ |
| testnvgraphevide                   |                         graphe vide                          | nouvel onglet avec un graphe vide                            |
| testnvgraphealeatoire()            |                             N/A                              | nouvel onglet avec un graphe aleatoire                       |
| testenregistrer()                  |                              G0                              | fichier graphe0.json créé                                    |
| testcharger()                      |                         graphe0.json                         | affichage de G0                                              |
| testenregistrersous()              |            G0 a l'emplacement "~\Bureau\graphe0"             | fichier graphe0.json a l'emplacement "~\Bureau\graphe0"      |
| testdupliquergraphe()              |                              G0                              | nouvel onglet avec G0                                        |
| testsupprimergraphe()              |                       O1,graphe0.json                        | suppression de l'onglet O1 et du fichier graphe0.json        |
| testfordBellman()                  |                              M0                              | affichage de <<<0>, <0,1>, <0, 2>, <0, 1, 3>, <0, 1, 3, 4>, <0, 2, 5>>, <0, 1, 1, 2, 3, 2>> dans la console |
| testfloydWarshall()                |                              M0                              | PM0 affiché dans la console                                  |
| testdegrsentrantetsortant()        |                    Matrice MA1, sommet 1                     | <1,1> affiché dans la console                                |
| testcolorationdegraphe()           |                              M0                              | <0, 1, 1> affiché dans la console                            |
| testdeterminationdestables()       |                             MA1                              | < <0,4,5>, <1,5,4>, <0,3,5>, <2,4> > affiché dans la console |

| testdeterminationdecliques()       | MA1                                                                                                                                                                                                        | <NULL> affiché dans la console               |
| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| testvoisinsdesommets()             | Matrice M3, sommet 0, sommet 7                                                                                                                                                                             | 32 affiché dans la console                   |
| testgestiondeflots()               | Matrice M3, sommet 0, sommet 7                                                                                                                                                                             | affiche 32 dans la console                   |
| testcreerungraphedordonnancement() | <{1,"",5,<>,<>>},{2,"",1,<>,<>},{3,"",7,<>,<>},{4,"",3,<2>,<>},{5,"",5,<1><>},{6,"",3,<1,4>,<>},{7,"",4,<1,3>,<>},{8,"",4,<1>,<>},{9,"",3,<8>,<>},{10,"",5,<6,7,9>,<>},{11,"",3,<8>,<>},{12,"",2,<11>,<>}> | affichage du graphe G2 dans un nouvel onglet |
| testarborescence()                 | Matrice M0                                                                                                                                                                                                 | affichage du graphe G' dans un nouvel onglet |
| testantiArborescence()             | Matrice M1                                                                                                                                                                                                 | affichage du graphe G'dans un nouvel onglet  |
| testrecherchedelaconnexite()       | M0                                                                                                                                                                                                         | int connexite = 1                            |
| testtrouverchaineeulerienne()      | G1                                                                                                                                                                                                         | <0,1,2,0>                                    |
| testtrouverchainehamiltonienne()   | G1                                                                                                                                                                                                         | <0,1,2>                                      |

| testpostierchinois()     |               MA1               | affichage de <0,1,2> sur la console    |
| ------------------------ |:-------------------------------:| -------------------------------------- |
| testvoyageurdecommerce() |      Matrice MA1, <0,1,2>       | affichage de <0,1,2> sur la console    |
| testextraireSousGraphe() |       G0,selection de G0'       | affichage de G0' dans un nouvel onglet |
| testarrangerSommets()    | graphe avec 3 sommet superposés | les sommet ne sont plus superposé      |
| testDBEselection()       |               N/A               | 1                                      |
| testDBEaddSommet()       |               N/A               | 2                                      |
| testDBEaddArc()          |               N/A               | 3                                      |
| testDBEdeleteSommet()    |               N/A               | 4                                      |
| testDBEdeleteArc()       |               N/A               | 5                                      |

| ############################ |         classe Zone de Dessin         | ################                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ---------------------------- |:-------------------------------------:| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| testZoneDeDessin()           |                  N/A                  | 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| testDestructeur ()           |                  N/A                  | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| testForce\_Atlas2()          |    graphe avec 3 sommet superposés    | les sommet ne sont plus superposés                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| testDistance()               | S0(posX=0, posY=0),S1(posX=1, posY=1) | \<1,1\>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| testAddSelect\_Sommet()      |                  S0                   | <0>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| testDeleteSelect\_Sommet()   |     liste = \<0,1,2\> Sommet = 1      | <0,2>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| testRazSelected\_list()      |                 <0,1>                 | <>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| testAfficher\_Graphe()       |  Graphe = G0 avec un sommet en (0,0)  | this.scene->itemAt(0,0) == sommet en 0,0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Test des getters             |                  N/A                  | this.selected_list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Test des setters             |                <0,1,2>                | this.selected_list == <0,1,2>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| testAfficher\_arc()          |                  A5                   | this.scene->itemAt(1,1) == A5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| testDessiner_Arc()           |                  QA0                  | this.scene->item() ne contient plus QA0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| testDessiner_Sommet()        |                  QS0                  | this.scene->item() ne contient plus QS0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| mousePressEvent()            |            e.pos() = <1,1>            | - Si "addSommetButton" enclenché : this.itemAt(1,1) == new Sommet<br />- Si addArcButton enclenché : this.itemAt(1,1) == new Arc<br />- Si "selectButton" est enclenché et "select" du sommet cliqué est sur "false" : sommet cliqué dans "selected_list"<br />- Si "selectButton" est enclenché et "select" du sommet cliqué est sur "true" : sommet cliqué retiré de "selected_list"<br />- Si "deleteSommet" est enclenché le sommet cliqué n'est plus dans "this.scene->items".<br />- Si "deleteArc" est enclenché l'arc cliqué n'est plus dans "this.scene->items" |

| ############################ |                                               classe QSommet                                               | ##################                                                                                                          |
| ---------------------------- |:----------------------------------------------------------------------------------------------------------:| --------------------------------------------------------------------------------------------------------------------------- |
| testSommet()                 |                                           QS0 = new QSommet(S0)                                            | QS0 == true                                                                                                                 |
| testDestructeur()            |                                                delete(QS0)                                                 | QS0 == false                                                                                                                |
| testMouseDoubleClickEvent()  |                                                    N/A                                                     | affichage de la fenetre de modification                                                                                     |
| testBoundingRect()           |                                             QS0 + clic(25,32)                                              | le clic est sur le sommet                                                                                                   |
| testSetSelect()              |                                           QS0.selected == false                                            | QS0.selected == true                                                                                                        |
| testgetter()                 |                                                    QS0                                                     | QS0.getid() == 0; QS0.getposx == 23; QS0.getposy == 32; QS0.getrayon == 5; QS0.getcoul == "white"; QS0.getselected == false |
| testsetter()                 | QS0.setid(1); QS0.setposx(1); QS0.setposy(1); QS0.setrayon(1); QS0.setcoul("green") ;QS0.setselected(true) | QS0.getid() == 1; QS0.getposx == 1; QS0.getposy == 1; QS0.getrayon == 1; QS0.getcoul == "green"; QS0.getselected == true    |


| ############################       |                         classe QArc                          | ##################                                           |
| ---------------------------------- | :----------------------------------------------------------: | ------------------------------------------------------------ |
| testArc()                         |   QA1 = new QArc(A1)                                                           |   QA1 == true |
| testDestructeur()                  |  delete(QA1)                                                            |          QA1 == NULL                                                    |
| testMouseDoubleClickEvent()        |  N/A                                                            |            N/A                                                  |
| testBoundingRect()                 | QAT avec comme coordonné (0,0)(2,2)                                                      | si clique en (1,1) verifié que QAT est bien selectionné                                                              |
| Test des getters                   | QA1                                                                                                                                                                                                           | QA1.getposxA() == A1.getSdepart().getposx() QA1.getposyA() == A1.getSdepart().getposy() QA1.getposxB() == A1.getSarrive().getposx() QA1.getposyB() == A1.getSarrive().getposy() QA1.getid() == A1.getid()          |     
| Test des setters                   | QA1.setposxA(1) QA1.setposyA(1) QA1.setposyB(3) QA1.setposxB(3)  QA1.setid(12)                                                                                                                                                                                                     |  QA1.getposxA() == 1 QA1.getposyA() == 1 QA1.getposxB() == 3 QA1.getposyB() == 3 QA1.getid() == 12                                                                                                        |

| **############################** | classe ordoCreate | **################## |
| ---------------------------------- | :----------------------------------------------------------: | ------------------------------------------------------------ |
| testOrdoCreate() | N/A | 1 |
| testDestructeur() | N/A | 0 |
| testAjoutTache()             | DureelineEdit->text() == 1<br />TacheAnterieurlineEdit->text() == NULL<br />IDlineEdit->text() == 0<br />nomDeLaTacheLineEdit->text() == "Lorem Ipsum" | pret_row r<br />r.tache == 0<br />r.nom_tache == "Lorem Ipsum"<br />r.duree == 1<br />r.taches_anterieures == NULL<br />r.taches_posterieures == NULL<br /><br />Ainsi que tableWidget->itemAt(0,i) avec i parcourant toutes les colonnes qui correpond successivement à : ID, nom de la tâche, durée, tâches antérieurs, tâches postérieurs. |
| testSupprimerTache()         | tableWidget avec en ligne 0 une tâche T0.<br />Une case de la ligne 0 est sélectionnée | la ligne 0 n'existe plus (si c'était la dernière) OU a changé de valeur (la ligne du dessous est montée) |
| Test des Getters             | this.res = < [0,"T0", 1, NULL, NULL] > | getRes == < [0,"T0", 1, NULL, NULL] > |
| Test des Setters             | this.res = NULL<br />setRes(< [0,"T0", 1, NULL, NULL] >) | this.res == < [0,"T0", 1, NULL, NULL] > |


| **############################** |                                  **classe modifObjet**                                  | **##################**                                                                                                   |
| -------------------------------- |:---------------------------------------------------------------------------------------:| ------------------------------------------------------------------------------------------------------------------------ |
| testModifObjet()                 |                                           N/A                                           | 1                                                                                                                        |
| testDestructeur()                |                                           N/A                                           | 0                                                                                                                        |
| Test des Getters                 |                       this.res = <A1.etiquette, A1.Scharge_utile>                       | getRes == <A1.etiquette, A1.Scharge_utile>                                                                               |
| Test des Setters                 |             this.res = NULL<br />setRes = <A1.etiquette, A1.Scharge_utile>              | this.res == <A1.etiquette, A1.Scharge_utile>                                                                             |
| testSuppripmerCU()               | tableWidget avec en ligne 0 une tâche CU0.<br />Une case de la ligne 0 est sélectionnée | la ligne 0 n'existe plus (si c'était la dernière) OU a changé de valeur (la ligne du dessous est montée)                 |
| void testAddCu()                 |             NomlineEdit->text() == "Poid"<br />ValeurlineEdit->text() == 1              | Ainsi que tableWidget->itemAt(0,i) avec i parcourant toutes les colonnes qui correpond successivement à : nom et valeur. |