Fonctions de test

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

Voir aussi Remplacer les fonctions.

Fonctions de test intégrées

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

cache(variablename, [set|add|sub] [transient] [super|stash], [source variablename])

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 peut être utilisée pour tester les variables placées dans la variable CONFIG. C'est la même chose que pour scopes, mais avec l'avantage supplémentaire qu'un second paramètre peut être passé pour tester la configuration active. Comme l'ordre des valeurs est important dans les variables CONFIG (c'est-à-dire que la dernière valeur définie sera considérée comme la configuration active pour les valeurs mutuellement exclusives), un second 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

Parce que release est considéré comme le paramètre actif (pour l'analyse des fonctionnalités), il sera la CONFIG utilisée pour générer le fichier de compilation. Dans le cas courant, un deuxième paramètre n'est pas nécessaire, mais pour des tests d'exclusivité mutuelle spécifiques, il est inestimable.

contains(variablename, value)

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'un champ d'application.

Par exemple, il est possible de vérifier la valeur de retour de cette fonction en utilisant un champ d'application :

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

Le contenu du scope n'est traité que si la variable drivers contient la valeur network. Si c'est le cas, les fichiers appropriés sont ajoutés aux variables SOURCES et HEADERS.

count(nom de la variable, nombre)

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

Cette fonction est utilisée pour s'assurer que les déclarations à l'intérieur d'une portée ne sont traitées que si la variable contient le nombre correct de valeurs. En voici un exemple :

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

debug(level, message)

Vérifie si qmake fonctionne au niveau de débogage spécifié. Si oui, il renvoie true et imprime un message de débogage.

defined(nom[, type])

Teste si la fonction ou la variable name est définie. Si type est omis, toutes les fonctions sont vérifiées. 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 ne vérifie que les variables

equals(nom de la variable, valeur)

Teste 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 comme message d'erreur à l'utilisateur et quitte. Cette fonction ne doit être utilisée que pour les erreurs irrécupérables.

Par exemple : eval(string)

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

eval(chaîne)

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

Par exemple :

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

exists(nom de fichier)

Teste si un fichier portant le nom filename 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, la fonction réussit si un fichier correspond.

Par exemple :

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

export(nom de la variable)

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

for(iterate, liste)

Démarre une boucle qui passe en revue toutes les valeurs de list, en attribuant à iterate chaque valeur à tour de rôle. Par commodité, si list vaut 1..10, iterate parcourra les valeurs de 1 à 10.

Par exemple, les boucles peuvent être interrompues à l'aide de la touche

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() saute le reste du corps de la boucle et poursuit l'exécution avec l'itération suivante.

greaterThan(nom de la variable, valeur)

Teste que la valeur de variablename est supérieure à value. Cette fonction tente d'abord une comparaison numérique. Si au moins l'un des opérandes n'est pas converti, cette fonction effectue une comparaison de chaînes de caractères.

Par exemple, il est impossible de comparer deux nombres sous la forme d'une chaîne de caractères :

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, construisez des valeurs temporaires avec un préfixe non numérique et comparez-les.

Par exemple, il est possible de construire des valeurs temporaires avec un préfixe non numérique et de les comparer :

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

Voir aussi lessThan().

if(condition)

Évalue condition. Il est utilisé pour regrouper des expressions booléennes.

Par exemple, il est utilisé pour regrouper des expressions booléennes :

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

include(nom de fichier)

Inclut le contenu du fichier spécifié par filename dans le projet actuel à 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 été inclus en utilisant cette fonction comme condition pour un champ d'application. 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 une valeur de val; sinon, échoue. Si vous ne spécifiez pas val, la fonction teste si var a été assigné dans le fichier.

isActiveConfig

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

isEmpty(nomdevariable)

Réussit si la variable variablename est vide, sinon échoue. C'est l'équivalent de count( variablename, 0 ).

Par exemple, la fonction

isEmpty( CONFIG ) {
CONFIG += warn_on debug
}

isEqual

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

lessThan(nomvariable, valeur)

Teste que la valeur de variablename est inférieure à value. Fonctionne comme greaterThan().

Par exemple :

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

load(feature)

Charge le fichier d'éléments (.prf) spécifié par feature, à moins que l'élément n'ait déjà été chargé.

log(message)

Imprime un message sur la console. Contrairement à la fonction message, cette fonction ne précède pas le texte et n'ajoute pas de retour à la ligne.

Cette fonction a été introduite dans Qt 5.0.

Voir aussi message().

message(string)

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

message( "This is a message" )

La ligne ci-dessus permet d'écrire "Ceci est un message" dans la console. L'utilisation de guillemets est facultative, mais recommandée.

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

mkpath(dirPath)

Crée le chemin du répertoire dirPath. Cette fonction est une enveloppe 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 construction.

system(command)

Exécute la commande command dans un shell secondaire. Réussit si la commande retourne avec un statut de sortie nul, sinon échoue. Vous pouvez vérifier la valeur de retour de cette fonction à l'aide d'un champ d'application.

Par exemple, vous pouvez vérifier la valeur de retour de cette fonction à l'aide d'un champ d'application :

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

Voir aussi la variante replace de system().

touch(nom_de_fichier, nom_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(variablename, versionNumber)

Teste que le numéro de version de variablename est supérieur ou égal à versionNumber. Le numéro de version est considéré comme une séquence de nombres décimaux non négatifs délimités par "." ; toute queue non numérique de la chaîne sera ignorée. La comparaison est effectuée par segment, de gauche à droite ; si une version est un préfixe de l'autre, elle est considérée comme plus petite.

Cette fonction a été introduite dans Qt 5.10.

versionAtMost(variablename, versionNumber)

Teste que le numéro de version de variablename est inférieur ou égal à versionNumber. Fonctionne comme versionAtLeast().

Cette fonction a été introduite dans Qt 5.10.

warning(string)

Réussit toujours et affiche string comme message d'avertissement à l'utilisateur.

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

Écrit les valeurs de variablename dans un fichier portant le nom filename, chaque valeur se trouvant 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à, il est ajouté au lieu d'être remplacé.

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. En voici un exemple :

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

Et ensuite, 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 pour l'ensemble 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 pour lesquels have_no_default ou no_<target>_target est spécifié dans leur .CONFIG 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 de sous-dossier. En outre, pour que ces cibles agissent, les sous-projets qui ne font pas partie des sous-dossiers 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, le fichier de fonctionnalités doit être injecté dans le projet :

# <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 par .qmake.conf :

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

Cette fonction a été introduite dans Qt 5.0.

qtCompileTest(test)

Construit un projet de test. Si le test réussit, true est renvoyé et config_<test> est ajouté à la variable CONFIG. Dans le cas contraire, false est renvoyé.

Pour que cette fonction soit 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 comme étant le sous-répertoire config.tests du répertoire parent du projet. Il est possible de remplacer cette valeur après avoir chargé le fichier de fonctionnalités.

Dans le répertoire des tests, il doit y avoir un sous-répertoire par test qui contient un simple projet qmake. 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 illustre l'invocation du test :

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

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

Les résultats du test 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 premier niveau.

Pour supprimer la réutilisation des résultats mis en cache, passez CONFIG+=recheck à qmake.

Voir aussi 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.