Tests

Mise à jour : Debian 10.0 Buster

Sommaire

1 - Principe

On distingue deux types de test

• Les tests réalisés sur le résultat (réussi ou non) d'une commande

• Les tests réalisés sur l'évaluation (satisfaite ou non) d'une condition

2 - Tests sur le résultat d'une commande

• Des tests peuvent être réalisés sur le résultat (réussi ou non) de toute commande. La valeur du paramètre de sortie de la commande ($?) est utilisé pour juger du résultat du test : si le paramètre de sortie est 0, le test a réussi, si le paramètre de sortie est différent de zéro, le test a échoué.
  

• Exemple de test réussi sur une commande
  

$ date
mercredi 10 février 2021, 18:37:30 (UTC+0100)

$ echo $?
0

• Exemple de test échoué sur une commande
  

 $ date -h
date : option invalide -- 'h'
Saisissez « date --help » pour plus d'informations.

$ echo $?
1

• Les commandes true et false peuvent être utilisés pour réaliser des tests dont les résultats sont toujours respectivement réussis et échoués
  

$ true 
$ echo $?
0

$ false
$ echo $?
1

3 - Tests sur l'évaluation d'une condition

3.1 - Principe

• Les commandes permettant de réaliser des tests sur l'évaluation d'une condition sont de la forme:
  

• test <condition>, par exemple
  

$ test 5 = 8
$ echo $?
1

• crochet simple [ <condition> ], par exemple
  

$ [ 5 = 8 ]
$ echo $?
1 

• double crochets : [[ <condition> ], par exemple
  

$ [[ 5 = 8 ]]
$ echo $?
1 

Dans les exemples ci-dessus, la condition testées est 5 = 8, le résultat est 1, le test échoue

• Ces trois formes ont des syntaxes parfois communes parfois différentes. Dans ce qui suit, on utilisera exclusivement, la syntaxe avec double crochets, qui est propre à bash et est non disponible dans sh.

• Noter que à l'intérieur des crochets d'ouverture et de fermeture, des espaces sont obligatoires entre chaque élément

3.2 - Test sur les chaînes de caractère

• Test unitaire - Test sur l'existence d'une chaîne de caractères
  

TEST                         # TEST réussi si 
---------------------------------------------------------------------------------

[[ "Exemple" ]]           # La chaîne de caractères "Exemple" comprend au moins 1 caractère
[[ -n "Exemple" ]]              # La chaîne de caractère "Exemple" comprend au moins 1 caractère
[[ -z "Exemple" ]]              # La chaîne de caractère "Exemple" comprend 0 caractères

• Tests binaires (sur deux variables) - Comparaison de deux chaînes de caractère
  

     TEST                    # TEST réussi si 
---------------------------------------------------------------------------------

[[ chaîne1 = chaîne2 ]]           # Les chaînes de caractère sont identiques
[[ chaîne1 != chaîne2 ]]          # Les chaînes de caractère sont différentes

• Exemple
  

$ [[ abcde = abcde ]]
$ echo $?
0

3.3 - Test sur les nombres

• Comparaison de valeurs
  

     TEST            # TEST réussi si 
---------------------------------------------------------------------------------

[[ val1 -eq val2 ]]     # Val1 et val2 sont égaux
[[ val1 -ne val2 ]]     # Val1 et val2 sont différents
[[ val1 -lt val2 ]]        # Val1 inférieure à val2
[[ val1 -gt val2 ]]     # Val1 supérieure à val2
[[ val1 -ge val2 ]]     # Val1 supérieure ou égal à val2
[[ val1 -le val2 ]]         # Val1 inférieure ou égal à val2

• Note : il est aussi possible de comparer deux valeurs en utilisant les commandes de calcul arithmétique

TEST                 # TEST réussi si 
---------------------------------------------------------------------------------

(( val1 == val2 ))        # Val1 et val2 sont égaux
(( val1 != val2 )) # Val1 et val2 sont différents
(( val1 <= val2 )) # Val1 est inférieur ou égal à valeur 2
(( val1 > val2 )) # val1 est supérieur à val2

• dans ce cas, les espaces entre les éléments ne sont pas obligatoires

$ ((5<=2**3))             # Équivalent à (( 5<= 2**3) etc ....

$ echo $?
0

• Autre exemple : test de la longueur d'une chaîne de caractères
  

$ chaine=aazerazer
$ [[ ${#chaine} -ge 5 ]]          # Test réussi si la longueur de la chaîne est supérieure à 5

3.4 - Test sur les fichiers

• Tests unitaires (sur une variable)

     TEST            # TEST réussi si                
----------------------------------------------------------------------------------

[[ -e  fichier ]]         # Fichier existe
[[ -f  fichier ]]       # Fichier existe et est ordinaire
[[ -d  répertoire ]]    # Répertoire existe
[[ -L  lien ]]          # Lien est un lien symbolique
[[ -x  fichier ]]       # Fichier existe et est exécutable
[[ -r  fichier ]]       # Fichier existe et est ouvert en lecture
[[ -w  fichier ]]       # Fichier existe et est ouvert en écriture
[[ -s  fichier ]]       # Fichier existe et a une taille supérieure à 0 octets

• Tests binaires (sur deux variables)
  

     TEST                    # TEST réussi si                
----------------------------------------------------------------------------------
[[ fichier1 -ef fichier2 ]]   # Fichier1 et fichier2 ont les mêmes numéros de périphérique et d'inoeud
[[ fichier1 -nt fichier2 ]]         # Fichier1 est plus récent (newer than) fichier2
[[ fichier1 -ot fichier2 ]]         # Fichier1 est plus ancien (older than) fichier2

4 - Opérateurs logiques

• 3 opérateurs logiques sont disponibles pour combiner les tests basés sur les test de commandes et de conditions
  
• ! >> Non logique : inversion du résultat du test
  
• && >>Et logique sur deux tests : test réussi si les deux tests sont réussis
  
• || >>Ou logique sur deux tests : test réussi si l'un ou l'autre des tests est réussi
• Note : L'opérateur de test "test" accepte les options -a (pour and) et -e (pour either) pour la combinaison de conditions, ils ne doivent pas être utilisés dans la syntaxe bash [[ <conditions> ]]

4.1 - Non logique

L'opérateur ! inverse le résultat du test devant lequel il est situé

• Inversion du résultat d'une commande
  

$ ! data

Command 'data' not found, did you mean:
.....

$ echo $?
0

• Inversion du résultat d'un test
  

$ ! [[ cinq = cinq ]]
$ echo $?
1

• Note : Ne pas confondre ! avec l'opérateur != , utilisé

• pour comparer des chaînes de caractère

$ [[ cinq != huit ]]
$ echo $?
0

• ou pour exécuter des opérations arithmétiques

$ (( 5!=8 ))
$ echo $?
0

4.2 - Et logique

L'opérateur && combine le résultat de deux tests : le test réussit si les deux tests sont réussis

• & logique sur deux commandes

$ true && true
$ echo $?
0

$ true && false
$ echo $?
1

• & logique sur deux tests,
  

$ [[ toto = toto && titi = tata ]]
$ echo $?
1

équivalent à

$ [[ toto = toto ]] && [[ titi = tata ]]
$ echo $?
1

• & logique sur une commande et un test
  

$ true && [[ titi = titi ]]
$ echo $?
0

4.3 - Ou logique

L'opérateur || combine le résultat de deux tests : le test réussit si l'un des deux tests réussit

• Ou logique exemple : une condition est vraie, la combinaison réussit
  

$ [[ toto = toto || titi = tata ]]
$ echo $?
0

• Équivalent à

$ [[ toto = toto ]] || [[ titi = tata ]]

• Ou logique exemple : les deux conditions sont fausses, la combinaison échoue
  

$ [[ toto = titi || titi = tata ]]
$ echo $?
1