---
# System prepended metadata

title: TP 4 AI03 - JUnit

---

# TP 4 AI03 - JUnit

> **Anne-Soline GUILBERT--LY**
> **Amaury MICHEL**
> **Alexandre TAESCH**


![](https://i.imgur.com/Q6PDS0q.png)



## Introduction

JUnit est un framework open source pour le développement et le test d'unités en Java. Il fournit une structure pour écrire des tests unitaires, les exécuter et les analyser. Les tests unitaires sont des tests conçus pour vérifier le comportement spécifique d'une fonctionnalité. Les tests unitaires permettent aux développeurs de déterminer rapidement si une fonctionnalité donnée fonctionne correctement avant de procéder à un déploiement. Cela permet aux développeurs de repérer et de corriger les bogues avant qu'ils ne deviennent un problème pour les utilisateurs finaux.

JUnit est également très utile pour la réalisation d'essais de régression. Les tests de régression sont des tests conçus pour s'assurer que les fonctionnalités existantes n'ont pas été cassées par des modifications apportées à d'autres fonctionnalités. En exécutant des tests de régression régulièrement, les développeurs peuvent s'assurer que leurs modifications ne nuisent pas aux fonctionnalités existantes.

### Boites blanches et Boites Noires
Les tests unitaires sont une étape importante dans le développement logiciel, car ils permettent de s'assurer que les composants individuels du logiciel fonctionnent comme prévu. Les tests unitaires sont généralement réalisés par le développeur lui-même et peuvent être effectués à l'aide d'un certain nombre de méthodes. Les tests unitaires peuvent être classés en deux catégories génériques : les tests boîte noire et les tests boîte blanche.

Les **tests boîte noire** consistent à tester le code sans prendre en compte sa structure interne. Les tests boîte noire peuvent être effectués à l'aide de jeux de données pré-établis pour vérifier que le code produit les résultats attendus. Les tests boîte noire sont généralement plus faciles à mettre en œuvre et à maintenir car ils ne nécessitent pas une compréhension complète du code et peuvent être testés rapidement.

Les **tests boîte blanche**, par contre, considèrent explicitement la structure du code et sont plus difficiles à mettre en œuvre. Ces tests nécessitent une compréhension complète du code et peuvent être plus longs à exécuter. Les tests boîte blanche sont utiles pour détecter les erreurs qui ne peuvent être détectées par les tests boîte noire.

## Installation de JUnit sur Linux

Nous utilisons différentes distribution Unix, nous avons d'abord installé JUnit. Il y a plusieurs façons : 
1. Eclipse IDE + JUnit extension
2. VS Code + Test Runner for Java extension
3. Installation manuelle d'une version récente de JUnit (voir instructions ci-dessous)
```note!
1. Téléchargez le fichier JAR JUnit à partir du site Web officiel.

2. Placez le fichier JAR dans le répertoire de votre choix sur votre système Linux.

3. Ouvrez un terminal et déplacez-vous dans le répertoire où se trouve le fichier JAR.

4. Utilisez la commande suivante pour installer JUnit sur votre système Linux : java -jar jUnit.jar

5. Une fois l'installation terminée, vous pouvez commencer à utiliser JUnit sur votre système Linux.
```

Nous utiliserons principalement les 2 premières techniques, plus pratiques.

## Réalisation des tests

Nous avons utilisé une structure différente que celle initialement donnée.


Exemple code 

``` java
import java.util.*;

public class Tri
	{
	public static boolean compare(int ta1[], int ta2[])
	{
		int l1=ta1.length;
		int l2=ta2.length;
		for(int i=0;i<l1-1;i++)
		{
			if(ta1[i] !=ta2[i])
			{
				return(false);
			}
		}
		return(true);
	}


	public static boolean estTrie(int tableau[])
	{
		int longueur=tableau.length;
		
		for(int i=0;i<longueur-1;i++)
		{
			if(tableau[i]>tableau[i+1])
			{
				return(false);
			}
		}
		return(true);
	}

	
}
```
Voici les différents tests que nous avons créés : 

### public static boolean compare(int ta1[], int ta2[])
#### Test unitaire de la méthode Tri.compare
```java 
	public void testCompare1() {
		int tab3[] = {1,2,3};
        int tab3Equal[] = {1,2,3};
        assertTrue(Tri.compare(tab3, tab3Equal));
	}
	
	public void testCompare2() {
        int tab3[] = {1,2,3};
        int tab3NotEqual[] = {3,2,1};
        assertFalse(Tri.compare(tab3, tab3NotEqual));
	}
	
	public void testCompare3() {
        int tab3[] = {1,2,3};
        int tab3NotEqual2[] = {1,2,4};
        assertFalse(Tri.compare(tab3, tab3NotEqual2));
	}

	public void testCompare4() {
        int tab3[] = {1,2,3};
		int tab2[] = {1,2};       
		// Compare 2 tableaux de taille différentes
        assertFalse(Tri.compare(tab3, tab2));
	}
	
	public void testCompare5() {
        int tab3[] = {1,2,3};
		int tab2[] = {1,2};
        // Compare 2 tableaux de taille différentes
        assertFalse(Tri.compare(tab2, tab3));
	}
```

![](https://i.imgur.com/akifBLm.png)

![](https://i.imgur.com/2R5RgAK.png)

![](https://i.imgur.com/3LI9BW2.png)

Ces tableaux ne sont pas les bons input pour la fonction Compare, car de tailles différentes.


#### Coverage sur *compare* des i-chemins pour des tableaux vide et de taille 1 à 4
```java
	public void testCompareCoverage1() {		
		// Tableau vide => passe 0 fois dans la boucle
		int tabVide[] =  {};
		int tabVideEqual[] = {};
        assertTrue(Tri.compare(tabVide,  tabVideEqual));	
	}
	
	public void testCompareCoverage2() {
		// Tableau de taille 1 => passe 0 fois dans la boucle
		int tab1[] = {1};
		int tab1Equal[] = {1};
		
		assertTrue(Tri.compare(tab1,  tab1Equal));
	}
	
	public void testCompareCoverage3() {
		// Tableau de taille 2 => passe 1 fois dans la boucle
		int tab2[] = {1,2};
		int tab2Equal[] = {1,2};
		assertTrue(Tri.compare(tab2,  tab2Equal));
	}
	
	public void testCompareCoverage4() {
		// Tableau de taille 3 => passe 2 fois dans la boucle
        int tab3[] = {1,2,3};
        int tab3Equal[] = {1,2,3};
        assertTrue(Tri.compare(tab3, tab3Equal));
	}
	
	public void testCompareCoverage5() {
		// Tableau de taille 4 => passe 3 fois dans la boucle
        int tab4[] = {1,2,3,4};
        int tab4Equal[] = {1,2,3,4};
        assertTrue(Tri.compare(tab4,  tab4Equal));
    }
```

### public static boolean estTrie(int tableau[])
#### Test unitaire de la méthode estTrie
```java
	public void testEstTrie1(){
		int tabTrie[] = {1,2,3};
        assertTrue(Tri.estTrie(tabTrie));
	}
	
	public void testEstTrie2(){
        int tabNonTrie[] = {3,2,1};
        assertFalse(Tri.estTrie(tabNonTrie));
	}
```

#### Coverage sur *estTrie* des i-chemins pour des tableaux vide et de taille 1 à 4
```java
	public void testEstTrieCoverarge1(){
		// Tableau de taille 1 => passe 0 fois dans la boucle
        int tab0[] = {1};
        assertTrue(Tri.estTrie(tab0));
	}

	public void testEstTrieCoverarge2(){
		// Tableau de taille 2 => passe 1 fois dans la boucle
		int tab1[] = {1,2};
        assertTrue(Tri.estTrie(tab1));
	}

	public void testEstTrieCoverarge3(){
		// Tableau de taille 3 => passe 2 fois dans la boucle
        int tab2[] = {1,2,3};
        assertTrue(Tri.estTrie(tab2));
	}
	
	public void testEstTrieCoverarge4(){
		// Tableau de taille 4 => passe 3 fois dans la boucle
        int tab3[] = {1,2,3,4};
        assertTrue(Tri.estTrie(tab3));
	}
```

### private static void echanger(int tableau[],int i,int j)
On ne peut pas tester Tri.echanger car elle est private, soit inaccessible d'ici.

### public static void triBulleOptimise(int tableau[])
#### Test unitaire de la méthode *triBulleOptimise*
```java
	public void testTriBulleOptimise() {
        int tabNonTrie[] = {3,2,1};
        int tabTrie[] = {1,2,3};
        Tri.triBulleOptimise(tabNonTrie);
        assertArrayEquals(tabTrie, tabNonTrie);
    }
```

![](https://i.imgur.com/R51Uj5a.png)

Failure, la fonction triBulleOptimise n'est pas fonctionnelle, erreur dans sa définition, il faut remplacer "2" par "1".

#### Coverage sur *TriBulleOptimise* des i-chemins pour des tableaux vide et de taille 1 à 4
```java
    // Ne peut pas passer 0 fois dans la boucle do while à cause du "do"
	public void testTriBulleOptimiseCoverage1() {
    	// Passe 1 fois dans la boucle do while de triBulleOptimise
        int tab1[] = {};
        int tab1Trie[] = {};
        Tri.triBulleOptimise(tab1);
        assertArrayEquals(tab1, tab1Trie);
    }

    public void testTriBulleOptimiseCoverage2() {
        // Passe 2 fois dans la boucle do while de triBulleOptimise
        int tab2[] = {3,2,1};
        int tab2Trie[] = {1,2,3};
        Tri.triBulleOptimise(tab2);
        assertArrayEquals(tab2, tab2Trie);
    }

    public void testTriBulleOptimiseCoverage3() {
        // Passe 3 fois dans la boucle do while de triBulleOptimise
        int tab3[] = {4,3,2,1};
        int tab3Trie[] = {1,2,3,4};
        Tri.triBulleOptimise(tab3);
        assertArrayEquals(tab3, tab3Trie);
    }
```
![](https://i.imgur.com/tTBuceD.png)

![](https://i.imgur.com/fVRN4hi.png)

On ne peut pas passer plus d'une fois dans la boucle "do"



### public static void triSelection(int tableau[])
#### Test unitaire de la méthode *triSelection*

```java
    public void testTriSelection() {
        int tabNonTrie[] = {3,2,1};
        int tabTrie[] = {1,2,3};
        Tri.triSelection(tabNonTrie);
        assertArrayEquals(tabTrie, tabNonTrie);    
    }
```

#### Coverage sur *TriSelection* des i-chemins pour des tableaux vide et de taille 1 à 4
```java
    public void testTriSelectionCoverage1() {
        int tabVide[] = {};
        int tabVideTrie[] = {};
        Tri.triSelection(tabVide); // => passe 0 fois dans la boucle
        assertArrayEquals(tabVide, tabVideTrie);    
    }
        
    public void testTriSelectionCoverage2() {
        int tab1[] = {1};
        int tab1Trie[] = {1};
        Tri.triSelection(tab1); // => passe 0 fois dans la boucle
        assertArrayEquals(tab1, tab1Trie);    
    }
    
    public void testTriSelectionCoverage3() {
        int tab2[] = {2,1};
        int tab2Trie[] = {1,2};
        Tri.triSelection(tab2); // => passe 1 fois dans la boucle
        assertArrayEquals(tab2, tab2Trie);    
    }
    
    public void testTriSelectionCoverage4() {
        int tab3[] = {3,2,1};
        int tab3Trie[] = {1,2,3};
        Tri.triSelection(tab3); // => passe 2 fois dans la boucle
        assertArrayEquals(tab3, tab3Trie);   
    }

    public void testTriSelectionCoverage5() {
        int tab4[] = {4,3,2,1};
        int tab4Trie[] = {1,2,3,4};
        Tri.triSelection(tab4); // => passe 3 fois dans la boucle
        assertArrayEquals(tab4, tab4Trie);    
    }
```

## Bilan des tests

Ci-dessous un récapitulatif de nos tests effectués, parmi eux les tests qui ont ratés : 

![](https://i.imgur.com/rd6e008.png)


## Asserts

Ce sont des méthodes appartenant à l'API Java Assertion. Elles permettent aux développeurs de tester des conditions spécifiques et d'afficher des messages d'erreur si ces conditions ne sont pas remplies.

AssertTrue vérifie si une condition est vraie ou non. Si elle est vraie, la méthode ne produit aucune erreur et le programme continue de s'exécuter. Si elle est fausse, la méthode lance une AssertionError et le programme s'arrête.

AssertFalse fonctionne de la même manière, mais vérifie si une condition est fausse ou non. Si elle est fausse, elle ne produit aucune erreur et le programme continue de s'exécuter. Si elle est vraie, elle lance une AssertionError et le programme s'arrête.

AssertArrayEquals est une méthode statique d'assertion fournie par JUnit qui compare les tableaux pour déterminer s'ils sont égaux. Il compare les éléments des tableaux un par un et envoie un message d'erreur si l'un des éléments n'est pas égal. Cette méthode est utile pour tester des tableaux à l'intérieur des tests unitaires.


## Conclusion
### Point de vue sur ce type d’outils et sur leurs apports

JUnit est un framework de test open source très populaire et largement utilisé par les développeurs pour automatiser et valider les tests unitaires de leurs applications. Il est facile à apprendre et à utiliser et offre une couverture complète des tests unitaires. Cet outil permet également aux développeurs de mieux comprendre le comportement de leurs applications, d'identifier les bugs plus rapidement et d'améliorer la qualité des logiciels développés. En outre, il permet de réduire le temps et les efforts nécessaires à la mise en œuvre des tests unitaires. 

En résumé, nous pensons que JUnit et les outils de tests en général sont très nécessaires pour les développeurs et qu'ils contribuent grandement à améliorer la qualité des logiciels développés.