[C++] Ailes - Permettre aux tests unitaires d’être générés de manière intelligente et automatique

Les tests unitaires sont un moyen très efficace d’assurer la qualité des logiciels, que ce soit du point de vue de l’intervention précoce dans les tests ou des caractéristiques des tests unitaires qui peuvent être vérifiés à grande vitesse sans être affectés par l’interface utilisateur, donc le développement piloté par les tests prôné par l’industrie, le pilote de test mentionné ici se réfère davantage au pilote de test unitaire. Cependant, l’équipe générale de développement exécute encore rarement des tests unitaires de manière systématique, et les tests pour les logiciels applicatifs sont davantage réalisés par des équipes de tests professionnelles pour effectuer des tests en boîte noire. La plus grande difficulté des tests unitaires n’est pas que l’entrée et la sortie ne puissent pas être déterminées, après tout, elles sont déjà déterminées au stade de développement du module, mais que la rédaction de cas de test unitaire consommera beaucoup d’heures de travail pour les développeurs, et selon les statistiques pertinentes, le temps des cas de test unitaire dépassera même largement le temps de développement de la fonction elle-même. Voici quelques-unes des raisons les plus courantes pour lesquelles le développement n’écrit pas de tests unitaires :

●Les exigences sont toujours infinies, il reste encore des exigences fonctionnelles à réaliser à l’étape suivante, et il n’y a pas de temps pour remplir l’unité

●Il y a trop de tests unitaires à compléter, et il n’y a aucun moyen de commencer, donc je résiste subjectivement.

● Les tests unitaires sont difficiles à écrire. D’une part, la raison peut être que l’implémentation des fonctions fonctionnelles n’est pas suffisamment raisonnable, et d’autre part, il n’existe pas (ou inconnus) de cadres de tests unitaires et de frameworks mock utiles.

● Les tests unitaires ne sont pas inclus dans la charge de travail.

Deuxièmement, les exigences fonctionnelles restent instables, et la performance en coûts d’écriture de tests unitaires n’est pas élevée. En d’autres termes, si les exigences changent demain, non seulement le code fonctionnel sera supprimé, mais aussi les tests unitaires. Si vous n’écrivez pas de tests unitaires, cette partie de l’effort ne sera pas vaine.

En fait, la cause principale des points ci-dessus est que l’écriture des tests unitaires est trop longue, ce qui conduit finalement à la perte de puissance du moteur piloté par les tests, ce qui fait que la belle vision du développement piloté par les tests est bloquée dans le scénario réel, car il est trop difficile et coûteux de construire le moteur pour cette transmission. Les différentes unités « x » sur le marché et les frameworks de tests unitaires ne résolvent que le problème de la génération de trames externes pilotées par test, sans aucune logique de cas d’usage ni capacités de génération de données basées sur une compréhension approfondie des programmes. Par conséquent, cela rend les développeurs réticents à divers scénarios liés au développement. La sortie de Wings (actuellement pour C) résout l’un des plus grands problèmes pour les programmeurs, et a le potentiel de changer fondamentalement le statu quo des tests unitaires, ce qui soulagera efficacement la pression des tests en boîte noire au niveau système et des tests automatisés basés sur d’énormes ressources humaines.

Les cas de test de contraintes sont générés automatiquement par les programmes, et la technologie sous-jacente la plus critique est la technologie complexe d’analyse des paramètres. C’est-à-dire qu’il peut définir arbitrairement l’analyse syntaxique récursive imbriquée au niveau du compilateur pour des types arbitrairement complexes. Sans cette avancée dans cette technologie critique, le système automatique de génération de cas de test serait soit commercialement incapable, soit évoluerait pour produire des données de test conformes avec une très faible efficacité. Par exemple, le célèbre outil de fuzzing American Fuzzy Lop ne peut pas identifier le type de structure requis par le programme de l’utilisateur, et doit faire évoluer l’algorithme de recherche à partir de la couche la plus externe. Les caractéristiques du programme sont que l’entrée au niveau de l’interface et les besoins en données d’un module interne sont éloignés, et les données externes sont généralement transformées couche par couche de transformation complexe pour devenir le type de structure de données requis par le module interne, de sorte que la quantité de calcul et de temps nécessaires pour explorer depuis la couche externe sera inimaginable. Basé sur l’American Fuzzy Lop, pour pouvoir générer une instruction SQL légitime, le module interne du programme doit être exploré en quelques jours, loin d’être en quelques minutes ou heures. Une autre contrainte est que les entrées que chaque programme peut prendre en charge sont des données soigneusement structurées et compilées avec un grand nombre de règles, et il est très irréaliste et extrêmement chronophage de générer ces données par des méthodes aléatoires + exploratoires. Par conséquent, il n’est pas possible de générer des cas d’usage générés automatiquement à partir de la boîte noire ainsi que de l’entrée la plus externe.

Si le cas d’usage est généré à partir de l’analyse de la structure interne du logiciel, il est nécessaire d’avoir une compréhension approfondie de la structure de compilation du logiciel. Un système de génération de cas de test viable doit être basé sur le centre du programme (point d’entrée clé) comme point d’entrée de test le plus approprié. Les entrées de ces modules ont transformé les entrées floues en paramètres hautement structurés. Tant que ces structures complexes peuvent être identifiées, que les types de données complexes peuvent être dégradés en types de données simples étape par étape, et que la construction des paramètres peut être achevée en même temps, la génération de cas d’usage de conduite peut être automatiquement complétée.

Les tests basés sur module, qui peuvent être classés comme des tests unitaires traditionnels, constituent la meilleure façon de détecter et de contenir les défauts lors de la phase R&D. Cependant, en raison des limites des tests unitaires, un grand nombre de pilotes doivent être développés, et la promotion ainsi que l’application dans l’industrie sont très limitées. Bien sûr, des tests unitaires peuvent également être exécutés après l’intégration du système afin d’éviter la construction de programmes stub virtuels.

Le produit Wings de Nebulas Testing, lancé pour la première fois dans le monde il y a quelques jours, est un système intelligent et entièrement automatisé de génération de cas de test unitaire, qui a étudié et résolu les difficultés suivantes, et qui vous est désormais partagé.

(1) Analyse approfondie des paramètres du programme

Wings utilise la technologie sous-jacente du compilateur pour former des objets modules à partir du fichier source d’entrée selon la fonction. L’objet contient les paramètres d’entrée de la fonction, le type de valeur de retour et d’autres informations, qui peuvent être utilisées par le module de fonction pilote et le module de cas test. Chaque fichier est une unité qui effectue une analyse approfondie de chaque paramètre de chaque fonction qu’il contient, et peut réaliser un syntase et une décomposition précis pour les types imbriqués, types complexes, etc., expliquer les types complexes couche par couche comme types de données de base, et générer un fichier de description (PSD) de la structure des paramètres.

(2) Génération automatique de modules par entraînement de fonctions

Selon les informations de format du fichier PSD, toutes les fonctions de pilote du programme source testé sont générées automatiquement, et le processus de test unitaire ne dépend plus des développeurs pour écrire manuellement les fonctions de test, mais doit seulement compiler ensemble les fonctions de pilote générées et les fichiers sources testés, les résultats du test peuvent être exécutés et consultés. Le pilote de test génère automatiquement le programme à partir de la description du PSD, construit entièrement automatiquement tous les paramètres et variables globales nécessaires qui pilotent le test en question, et peut générer un pilote de test structuré selon la hiérarchie des variables complexes, ce qui permet de gagner beaucoup de temps dans l’écriture de cas de test unitaire.

(3) Génération et gestion automatiques des données de test

Il est utilisé pour générer automatiquement des données de test, qui correspondent aux informations extraites par la fonction de test et les données sont stockées dans un fichier JSON avec une certaine relation logique hiérarchique. Les données et le type de données après décomposition et expansion correspondent l’un à l’autre. Les utilisateurs peuvent marginaliser arbitrairement ces données selon les besoins métier, et utiliser des fichiers JSON pour les afficher de manière structurée et hiérarchique, ce qui est très clair. Les données de test incluent les valeurs des variables globales et les valeurs des paramètres lors de l’appel de la fonction testée.

Wings fournit une méthode de test unitaire pour générer automatiquement des fonctions de pilotage, qui comprend principalement les étapes suivantes :

Figure 1 : Flux de construction piloté par tests unitaires

Les informations structurales du programme testé incluent principalement les variables globales et les informations de fonction dans le programme, et les informations de fonction incluent principalement le nombre de paramètres, types de paramètres et types de valeurs de retour de la fonction. La chose la plus importante est d’extraire les informations sur les symboles et les types pour certains types complexes, puis de les analyser en types de données de base couche par couche afin de compléter la construction des variables globales et des paramètres de fonction.

Les types de variables sont généralement divisés en types de base, types de construction, types de pointeurs et types nuls. Wings utilise la technologie de compilation sous-jacente pour gérer différents types de variables de différentes manières.

(1) Les types de base, tels que int non signé u_int=20, Wings analyseront le nom de la variable en u_int et le type de données en int non signé.

(2) Types de construction, les types de construction sont grossièrement divisés en tableaux, structs, communs et types d’énumération.

● Type de tableau, tel que intarray[2][3], le nom du tableau est tableau, type int et longueur du tableau 2D, comportement 2, colonne 3.

●Type de structure, pour les structs en tant que tableaux, listes chaînées de structs, etc., différents marqueurs sont divisés.

(3) Type de pointeur, par exemple int **ptr = 0 ; , analyse le pointeur comme un pointeur de niveau 2 de type int.

(4) Type nul, qui est résolu comme NULL.

(5) Les types de systèmes, tels que fichier, size_t, etc., sont marqués comme types de système, et seront ajoutés au modèle et assignés par l’utilisateur.

(6) Type de pointeur de fonction, analyser le type de valeur de retour, le type de paramètre et le nombre de paramètres de la fonction

Pour chaque unité de compilation du programme source testé, les informations de fonction analysées sont stockées dans la structure PSD correspondante, et les exemples suivants de code source sont décrits :

   

Dans le programme ci-dessus, void StructTypeTest3(myy_struct mm_struct[2])La structure PSD enregistrée est la suivante :

Les significations de chaque nœud dans le fichier PSD sont les suivantes :

●StructTypeTest3 représente le nom de la fonction, parmType0 représente le type de paramètre, et parmNum représente le nombre de paramètres

●mm_struct représente le symbole du paramètre de fonction, baseType1 représente la classification des types (type de données de base, type construction, type pointeur, type nul), type représente des types spécifiques, y compris int, char, short, long, double, float, bool, et ces types de types non signés et autres types de base, et il existe certains types spéciaux tels que : ZOA_FUN type représente le type de fonction, StructureOrClassType représente le type de struct, etc., et le nom représente le nom du type de struct, d’union et d’enum

●i_int représente le type de base, qui est la plus petite unité d’affectation

●array_one représente le type de tableau, RowSize représente la longueur du tableau, et le tableau peut être divisé en tableaux unidimensionnels, bidimensionnels, etc

●point représente le type de pointeur, le pointeur est divisé en pointeur de premier niveau, pointeur de deuxième niveau, etc., et le pointeur général est utilisé comme paramètre de fonction en tant que tableau, ainsi, pour le type de pointeur de base, la méthode du tableau d’allocation dynamique est utilisée pour assigner des valeurs, et l’utilisateur peut modifier le fichier de valeurs correspondant selon ses besoins.

● w représente le type de champ de bits, et bitfileld représente le nombre de chiffres

●functionPtr représente le type de pointeur de fonction, qui analyse respectivement le type de paramètre, le nombre de paramètres et les informations de valeur de retour

●Dem signifie type de consortium

● dy représente le type d’enum, et value représente la valeur du type d’enum

●file représente le type de structure, SystemVar représente que cette variable appartient à la variable dans le fichier d’en-tête système, pour ce type de variable, Wings ajoute des variables modèles à la bibliothèque de modèles, les utilisateurs peuvent attribuer des valeurs spéciales selon des besoins spécifiques. Par exemple, le type de fichier est géré comme suit :

Les utilisateurs peuvent également ajouter leurs propres méthodes d’affectation. Pour les types de systèmes, les Wings peuvent être distingués des types définis par l’utilisateur ordinaires, et lors de l’analyse avec le type intégré du système, ils peuvent arrêter l’analyse récursive vers le bas.

●g_int représente les variables globales, et globalType représente les variables globales

●next représente la structure de liste chaînée, et NodeType représente cette structure comme une liste chaînée

●returnType représente le type de valeur de retour de la fonction.

Dans l’article ci-dessus, les informations structurelles des variables et fonctions globales sont analysées et extraites, et les informations suivantes sont utilisées pour sauvegarder dans le PSD afin de compléter la génération globale du cadre de pilotage du programme source testé.

La génération est principalement divisée en ces aspects :

Ø Déclaration des variables globales

Ø Opération d’attribution des paramètres de fonction, selon le nombre de paramètres de fonction, attribue à leur tour des valeurs

Ø L’attribution des variables globales est effectuée séquentiellement selon le nombre de variables globales utilisées par l’analyse

Ø Appel de la fonction originale

Voici quelques points à noter :

●Pendant le processus de génération du pilote, certaines fonctions spéciales, telles que les fonctions principales, statiques, etc., ne sont pas traitées temporairement car elles ne peuvent pas être accessibles par le monde extérieur.

● Pour chaque fichier source testé, un fichier pilote correspondant est généré.

● Le contrôle du lecteur est inclus dans le Driver_main.cpp pour configurer automatiquement le nombre de tests de la fonction via des macros

La fonction de pilotage générée par le programme source ci-dessus est la suivante :

● Toutes les variables sont nommées avant le nom de la variable originale, ajoutez _

●En obtenant les données de test correspondantes, les variables sont assignées à tour de rôle

●Pour les paramètres intégrés du système et les paramètres spéciaux de l’utilisateur, la méthode d’attribution est configurée de manière uniforme via la méthode modèle.

●Attribuer et appeler des paramètres à la fonction testée.

Voici un ensemble de données générées au format PSD dans la Figure 3, chaque ensemble de données est enregistré en format JSON, ce qui facilite la vision de la relation hiérarchique des données.

Pour chaque unité de compilation, un ensemble de fichiers de données de test correspondant à toutes les fonctions est généré par défaut, et la génération de valeur peut être modifiée en fonction du nombre de configurations.

Comment compléter la génération du cadre de pilotage, voici une explication détaillée de l’ensemble du processus de génération du programme open source MySQL.

Voici le diagramme principal de l’interface de Wings testant MySQL :

Cliquez sur le bouton Fichier pour définir le répertoire du projet du programme source testé. Une fois les paramètres terminés, cliquez sur l’opération de fonction, qui inclut principalement l’analyse des paramètres, la génération de pilotes, la génération de fichiers de valeur et l’ajout de modèles. Les dossiers suivants sont générés pour l’analyse :

Parmi eux, le module d’analyse des paramètres génère FunXml et GlobalXml, qui stockent respectivement les informations de fonction et les informations globales des variables de chaque unité de compilation extraite.

Le module de génération de pilotes sera généré Wings_Projects dossier correspondant, qui stocke les fichiers de pilotes pour chaque unité de compilation

Le module de génération de valeur stocke les données de test générées pour chaque unité de compilation.

La figure suivante montre les informations sur la structure du fichier de pilotes chargées par Mysql, et l’arbre de navigation à gauche est le fichier de pilote généré, qui contient les fonctions de chaque unité de compilation, ainsi que les paramètres et variables globales des fonctions. Cliquez sur l’une des unités de compilation pour charger le fichier de pilotes correspondant et le fichier de valeur correspondant.

Ce qui précède correspond au fichier de pilotes et au fichier de valeur correspondant à la génération globale de Mysql, et le fichier de pilote est décrit en détail dans le code suivant.

● Pour chaque unité de compilation, la référence de la variable globale est par externe.

●La fonction de pilote est uniformément nommée méthode Driver_XXX, JSON est utilisé pour obtenir des données de test, et les temps représentent le nombre de tests d’une seule fonction.

●Pour chaque opération d’assignation de paramètres, le format de stockage PSD analysé est utilisé pour attribuer des valeurs à chaque structure de couche à tour de rôle.

L’application de Wings est très simple : voici un index statistique des données de test générées à l’aide du code Mysql pouvant être compilé normalement dans Visual Studio 2015. Par exemple, tout le processus de génération ne nécessite aucune intervention manuelle, il suffit de formuler le chemin du code source à générer et piloter.

mysqlDonnées de test

Voici les résultats obtenus à l’aide de l’outil de statistiques du code source, avec plus de 4 millions de lignes de code unitaire valide générés par Wings de manière entièrement automatique. Ce qui est encore plus intéressant, c’est qu’on peut voir que le coût du développement manuel de ces codes peut atteindre 1 079 mois-homme, et le coût peut atteindre 10,79 millions.

Wings a réalisé la première étape d’exploration du programme pour générer automatiquement le programme, la première version est actuellement disponible, les développeurs intéressés peuvent la télécharger directement sur la plateforme Code Cloud (https://gitee.com/teststars/wings_release), la licence commerciale offre une période d’expérience illimitée d’un mois, vous pouvez rapidement découvrir la puissance magique de Wings, la version en langue C de Wings prend en charge plusieurs plateformes, telles que Visual Studio, VxWorks, GCC, QT, etc. Wings est conçu et développé par l’équipe de test (www.teststar.cc) de Nebulas, et les développeurs intéressés peuvent contacter l’équipe de test de Nebulas via la plateforme interactive de Codecloud pour partager leurs idées de conception et leurs retours sur l’utilisation des produits (pour les excellentes suggestions adoptées, Nebulas peut prolonger sa période d’utilisation gratuite d’au moins trois mois). Wings possède un gène solide et sous-jacent pour améliorer considérablement la qualité logicielle, et à l’avenir, Wings optimisera profondément la lisibilité des programmes écrits automatiquement (plus proche du niveau d’écriture des bons programmeurs) ainsi que le support du langage C++.