Fonctions de test

Les fonctions de test renvoient une valeur booléenne que vous pouvez vérifier dans les parties conditionnelles des portées. Les fonctions de test peuvent être classées en fonctions intégrées et en bibliothèques de fonctions.

Voir également Fonctions de remplacement.

Fonctions de test intégrées

Les fonctions de test de base sont implémentées en tant que fonctions intégrées.

cache(nom_variable, [set|add|sub] [transient] [super|stash], [nom_variable_source])

Il s'agit d'une fonction interne dont vous n'aurez généralement pas besoin.

Cette fonction a été introduite dans Qt 5.0.

CONFIG(config)

Cette fonction permet de vérifier la présence de variables placées dans la variable CONFIG. Elle est similaire à la fonction scopes, mais présente l'avantage supplémentaire de permettre de passer un deuxième paramètre pour vérifier la configuration active. L'ordre des valeurs étant important dans les variables d'CONFIG s (c'est-à-dire que la dernière valeur définie sera considérée comme la configuration active pour les valeurs mutuellement exclusives), un deuxième paramètre peut être utilisé pour spécifier un ensemble de valeurs à prendre en compte. Par exemple :

CONFIG = debug
CONFIG += release
CONFIG(release, debug|release):message(Release build!) #will print
CONFIG(debug, debug|release):message(Debug build!) #no print

Comme « release » est considéré comme le paramètre actif (pour l’analyse des fonctionnalités), c’est cette valeur CONFIG qui sera utilisée pour générer le fichier de compilation. Dans la plupart des cas, un deuxième paramètre n’est pas nécessaire, mais il s’avère indispensable pour certains tests spécifiques impliquant des valeurs mutuellement exclusives.

contains(nom_variable, valeur)

Réussit si la variable variablename contient la valeur value; sinon, échoue. Il est possible de spécifier une expression régulière pour la valeur du paramètre.

Vous pouvez vérifier la valeur de retour de cette fonction à l’aide d’une portée.

Par exemple :

contains( drivers, network ) {
    # drivers contains 'network'
    message( "Configuring for network build..." )
    HEADERS += network.h
    SOURCES += network.cpp
}

Le contenu de la portée n’est traité que si la variable drivers contient la valeur network. Si tel est le cas, les fichiers appropriés sont ajoutés aux variables SOURCES et HEADERS.

count(nom_variable, nombre)

Réussit si la variable variablename contient une liste comportant le number spécifié de valeurs ; sinon, échoue.

Cette fonction permet de s’assurer que les déclarations situées dans une portée ne sont traitées que si la variable contient le nombre correct de valeurs. Par exemple :

options = $$find(CONFIG, "debug") $$find(CONFIG, "release")
count(options, 2) {
    message(Both release and debug specified.)
}

debug(niveau, message)

Vérifie si qmake s'exécute au niveau de débogage spécifié. Si oui, elle renvoie « true » et affiche un message de débogage.

defined(name[, type])

Vérifie si la fonction ou la variable name est définie. Si type est omis, vérifie toutes les fonctions. Pour vérifier uniquement les variables ou un type particulier de fonctions, spécifiez type. Il peut prendre les valeurs suivantes :

• test vérifie uniquement les fonctions de test
• replace vérifie uniquement les fonctions de remplacement
• var vérifie uniquement les variables

equals(nom_variable, valeur)

Vérifie si variablename est égal à la chaîne value.

Par exemple :

TARGET = helloworld
equals(TARGET, "helloworld") {
    message("The target assignment was successful.")
}

error(chaîne)

Cette fonction ne renvoie jamais de valeur. qmake affiche string sous forme de message d’erreur à l’utilisateur et se termine. Cette fonction ne doit être utilisée que pour les erreurs irrémédiables.

Par exemple :

error(An error has occurred in the configuration process.)

eval(chaîne)

Évalue le contenu de la chaîne en respectant les règles syntaxiques de qmake et renvoie « true ». Des définitions et des affectations peuvent être utilisées dans la chaîne pour modifier les valeurs de variables existantes ou créer de nouvelles définitions.

Par exemple :

eval(TARGET = myapp) {
    message($$TARGET)
}

exists(filename)

Vérifie si un fichier portant l'filename donnée existe. Si le fichier existe, la fonction réussit ; sinon, elle échoue.

L'argument « filename » peut contenir des caractères génériques. Dans ce cas, cette fonction aboutit si un fichier quelconque correspond.

Par exemple :

exists( $(QTDIR)/lib/libqt-mt* ) {
      message( "Configuring for multi-threaded Qt..." )
      CONFIG += thread
}

export(nom_de_variable)

Exporte la valeur actuelle de ` variablename ` du contexte local d’une fonction vers le contexte global.

for(itération, liste)

Lance une boucle qui parcourt toutes les valeurs de ` list`, en attribuant tour à tour à ` iterate ` chacune de ces valeurs. Pour plus de commodité, si ` list ` est défini sur `1..10`, alors `iterate` parcourra les valeurs de 1 à 10.

Par exemple :

LIST = 1 2 3
for(a, LIST):exists(file.$${a}):message(I see a file.$${a}!)

Les boucles peuvent être interrompues à l’aide de ` break()`. L’instruction ` next() ` ignore le reste du corps de la boucle et poursuit l’exécution avec l’itération suivante.

greaterThan(nom_variable, valeur)

Vérifie si la valeur de ` variablename ` est supérieure à ` value`. Cette fonction effectue d’abord une comparaison numérique. Si au moins l’un des opérandes ne peut pas être converti, elle effectue alors une comparaison de chaînes de caractères.

Par exemple :

ANSWER = 42
greaterThan(ANSWER, 1) {
    message("The answer might be correct.")
}

Il est impossible de comparer directement deux nombres sous forme de chaînes de caractères. Pour contourner ce problème, créez des valeurs temporaires avec un préfixe non numérique et comparez-les.

Par exemple :

VALUE = 123
TMP_VALUE = x$$VALUE
greaterThan(TMP_VALUE, x456): message("Condition may be true.")

Voir également lessThan().

if(condition)

Évalue l'condition. Cette fonction est utilisée pour regrouper des expressions booléennes.

Par exemple :

if(linux-g++*|macx-g++*):CONFIG(debug, debug|release) {
    message("We are on Linux or Mac OS, and we are in debug mode.")
}

include(filename)

Inclut le contenu du fichier spécifié par filename dans le projet en cours, à l'endroit où il est inclus. Cette fonction réussit si filename est inclus ; sinon, elle échoue. Le fichier inclus est traité immédiatement.

Vous pouvez vérifier si le fichier a bien été inclus en utilisant cette fonction comme condition pour une portée. Par exemple :

include( shared.pri )
OPTIONS = standard custom
!include( options.pri ) {
    message( "No custom build options specified" )
OPTIONS -= custom
}

infile(filename, var, val)

Réussit si le fichier filename (lorsqu’il est analysé par qmake lui-même) contient la variable var avec la valeur val; sinon, elle échoue. Si vous ne spécifiez pas val, la fonction vérifie si var a été assignée dans le fichier.

isActiveConfig

Il s'agit d'un alias de la fonction CONFIG.

isEmpty(variablename)

Réussit si la variable variablename est vide ; sinon, échoue. Cela équivaut à count( variablename, 0 ).

Par exemple :

isEmpty( CONFIG ) {
CONFIG += warn_on debug
}

isEqual

Il s'agit d'un alias de la fonction ` equals `.

lessThan(nom_variable, valeur)

Vérifie si la valeur de ` variablename ` est inférieure à ` value`. Fonctionne de la même manière que `greaterThan()`.

Par exemple :

ANSWER = 42
lessThan(ANSWER, 1) {
    message("The answer might be wrong.")
}

load(feature)

Charge le fichier de caractéristiques (.prf) spécifié par feature, à moins que la caractéristique n'ait déjà été chargée.

log(message)

Affiche un message sur la console. Contrairement à la fonction message, elle n’ajoute pas de texte au début ni de saut de ligne à la fin.

Cette fonction a été introduite dans Qt 5.0.

Voir aussi message().

message(chaîne)

Réussit toujours et affiche « string » comme message général à l'intention de l'utilisateur. Contrairement à la fonction error(), cette fonction permet au traitement de se poursuivre.

message( "This is a message" )

La ligne ci-dessus provoque l'affichage de « This is a message » sur la console. L'utilisation de guillemets est facultative, mais recommandée.

!build_pass:message( "This is a message" )

mkpath(dirPath)

Crée le chemin d’accès au répertoire dirPath. Cette fonction est un wrapper autour de la fonction QDir::mkpath.

Cette fonction a été introduite dans Qt 5.0.

requires(condition)

Évalue condition. Si la condition est fausse, qmake ignore ce projet (et ses sous-répertoires) lors de la compilation.

system(commande)

Exécute l'command donnée dans un shell secondaire. Réussit si la commande renvoie un code de sortie égal à zéro ; sinon, échoue. Vous pouvez vérifier la valeur de retour de cette fonction à l'aide d'un scope.

Par exemple :

system("ls /bin"): HAS_BIN = TRUE

Voir également la variante « replace » de system().

touch(nom_fichier, nom_fichier_de_référence)

Met à jour l'horodatage de filename pour qu’il corresponde à celui de reference_filename.

Cette fonction a été introduite dans Qt 5.0.

unset(nom_de_variable)

Supprime variablename du contexte actuel.

Par exemple :

NARF = zort
unset(NARF)
!defined(NARF, var) {
    message("NARF is not defined.")
}

versionAtLeast(nom_variable, numéro_version)

Vérifie que le numéro de version de variablename est supérieur ou égal à versionNumber. Le numéro de version est considéré comme une suite de nombres décimaux non négatifs délimités par « . » ; toute partie non numérique à la fin de la chaîne sera ignorée. La comparaison s’effectue segment par segment, de gauche à droite ; si une version est un préfixe de l’autre, elle est considérée comme inférieure.

Cette fonction a été introduite dans Qt 5.10.

versionAtMost(nomDeVariable, numéroDeVersion)

Vérifie que le numéro de version de variablename est inférieur ou égal à versionNumber. Fonctionne de la même manière que versionAtLeast().

Cette fonction a été introduite dans Qt 5.10.

warning(chaîne)

Réussit toujours et affiche string sous forme de message d'avertissement à l'utilisateur.

write_file(filename, [variablename, [mode]])

Écrit les valeurs de ` variablename ` dans un fichier nommé ` filename`, chaque valeur sur une ligne distincte. Si ` variablename ` n'est pas spécifié, crée un fichier vide. Si ` mode ` est ` append ` et que le fichier existe déjà, ajoute les données à la fin du fichier au lieu de le remplacer.

Cette fonction a été introduite dans Qt 5.0.

Bibliothèque de fonctions de test

Les fonctions de test complexes sont implémentées dans une bibliothèque de fichiers .prf.

packagesExist(packages)

Utilise le mécanisme PKGCONFIG pour déterminer si les paquets donnés existent ou non au moment de l’analyse du projet.

Cela peut être utile pour activer ou désactiver certaines fonctionnalités de manière facultative. Par exemple :

packagesExist(sqlite3 QtNetwork QtDeclarative) {
    DEFINES += USE_FANCY_UI
}

Puis, dans le code :

#ifdef USE_FANCY_UI
    // Use the fancy UI, as we have extra packages available
#endif

prepareRecursiveTarget(target)

Facilite la création de cibles à l'échelle du projet, similaires à la cible ` install `, en préparant une cible qui parcourt tous les sous-répertoires. Par exemple :

TEMPLATE = subdirs
SUBDIRS = one two three
prepareRecursiveTarget(check)

Les sous-répertoires dont le fichier .CONFIG spécifie « have_no_default » ou « no_<target>_target » sont exclus de cette cible :

two.CONFIG += no_check_target

Vous devez ajouter manuellement la cible préparée à QMAKE_EXTRA_TARGETS:

QMAKE_EXTRA_TARGETS += check

Pour que la cible soit globale, le code ci-dessus doit être inclus dans chaque sous-projet « subdirs ». De plus, pour que ces cibles fonctionnent, les sous-projets autres que « subdirs » doivent inclure le code correspondant. Le moyen le plus simple d’y parvenir est de créer un fichier de fonctionnalités personnalisé. Par exemple :

# <project root>/features/mycheck.prf
equals(TEMPLATE, subdirs) {
    prepareRecursiveTarget(check)
} else {
    check.commands = echo hello user
}
QMAKE_EXTRA_TARGETS += check

Le fichier de fonctionnalités doit être injecté dans chaque sous-projet, par exemple via .qmake.conf :

# <project root>/.qmake.conf
CONFIG += mycheck

Cette fonctionnalité a été introduite dans Qt 5.0.

qtCompileTest(test)

Compile un projet de test. Si le test réussit, la valeur true est renvoyée et config_<test> est ajouté à la variable CONFIG. Sinon, la valeur false est renvoyée.

Pour rendre cette fonction disponible, vous devez charger le fichier de fonctionnalités correspondant :

# <project root>/project.pro
load(configure)

Cela définit également la variable QMAKE_CONFIG_TESTS_DIR sur le sous-répertoire « config.tests » du répertoire parent du projet. Il est possible de redéfinir cette valeur après le chargement du fichier de fonctionnalités.

À l’intérieur du répertoire tests, il doit y avoir un sous-répertoire par test contenant un projet qmake simple. L’extrait de code suivant illustre le fichier .pro du projet :

# <project root>/config.tests/test/test.pro
SOURCES = main.cpp
LIBS += -ltheFeature
# Note that the test project is built without Qt by default.

L'extrait de code suivant illustre le fichier .cpp principal du projet :

// <project root>/config.tests/test/main.cpp
#include <TheFeature/MainHeader.h>
int main() { return featureFunction(); }

L'extrait de code suivant montre l'appel du test :

# <project root>/project.pro
qtCompileTest(test)

Si le projet de test est compilé avec succès, le test est réussi.

Les résultats des tests sont automatiquement mis en cache, ce qui les rend également disponibles pour tous les sous-projets. Il est donc recommandé d’exécuter tous les tests de configuration dans le fichier de projet de niveau supérieur.

Pour désactiver la réutilisation des résultats mis en cache, passez l'CONFIG+=recheck e à qmake.

Voir également load().

Cette fonction a été introduite dans Qt 5.0.

qtHaveModule(name)

Vérifie si le module Qt spécifié par name est présent. Pour une liste des valeurs possibles, voir QT.

Cette fonction a été introduite dans Qt 5.0.1.