Vue d’ensemble de Microsoft IntelliTest

IntelliTest vous permet de rechercher des bogues tôt et de réduire les coûts de maintenance des tests. À l’aide d’une approche de test automatisée et transparente, IntelliTest peut générer une suite de tests candidate pour votre code .NET. La génération de suite de test peut être guidée par les propriétés de correction que vous spécifiez. IntelliTest évoluera même automatiquement la suite de tests à mesure que le code sous test évolue.

Tests de caractérisation IntelliTest vous permet de déterminer le comportement du code en termes d’une suite de tests unitaires traditionnels. Une telle suite de tests peut être utilisée comme suite de régression, ce qui constitue la base pour résoudre la complexité associée à la refactorisation du code hérité ou inconnu.

Génération d’entrée de test guidée IntelliTest utilise une approche ouverte d’analyse du code et de résolution de contraintes pour générer automatiquement des valeurs d’entrée de test précises ; généralement sans avoir besoin d’une intervention de l’utilisateur. Pour les types d’objets complexes, il génère automatiquement des fabriques. Vous pouvez guider la génération d’entrée de test en étendant et en configurant les fabriques en fonction de vos besoins. Les propriétés de correction spécifiées en tant qu’assertions dans le code sont utilisées automatiquement pour guider davantage la génération d’entrée de test.

Intégration de l’IDE IntelliTest est entièrement intégré à l’IDE Visual Studio. Toutes les informations collectées pendant la génération de la suite de tests (telles que les entrées générées automatiquement, la sortie de votre code, les cas de test générés et leur état de réussite ou d’échec) apparaissent dans l’IDE Visual Studio. Vous pouvez facilement itérer entre corriger votre code et réexécuter IntelliTest, sans quitter l’IDE Visual Studio. Les tests peuvent être enregistrés dans la solution en tant que projet de test unitaire et sont détectés automatiquement par la suite par l’Explorateur de tests Visual Studio.

Compléter les pratiques de test existantes Utilisez IntelliTest pour compléter toutes les pratiques de test existantes que vous pouvez déjà suivre.

Si vous souhaitez tester :

• Algorithmes sur des données primitives ou des tableaux de données primitives :
  • écrire des tests unitaires paramétrables
• Algorithmes sur des données complexes, telles que le compilateur :
  • Laissez IntelliTest d’abord générer une représentation abstraite des données, puis le nourrir à l’algorithme
  • laissez IntelliTest générer des instances à l’aide de la création d’objets personnalisés et des invariants de données, puis appelez l’algorithme
• Conteneurs de données :
  • écrire des tests unitaires paramétrables
  • Laissez IntelliTest générer des instances à l’aide de la création d’objets personnalisés et des invariants de données, puis appelez une méthode du conteneur et revérifiez les invariants par la suite.
  • écrire des tests unitaires paramétrables qui appellent différentes méthodes de l’implémentation, en fonction des valeurs de paramètre
• Base de code existante :
  • Utiliser l’Assistant IntelliTest de Visual Studio pour commencer à générer un ensemble de tests unitaires paramétrables (PUT)

Le Hello World d’IntelliTest

IntelliTest recherche des entrées pertinentes pour le programme testé, ce qui signifie que vous pouvez l’utiliser pour générer la célèbre chaîne Hello World ! Cela suppose que vous avez créé un projet de test MSTest C# et ajouté une référence à Microsoft.Pex.Framework. Si vous utilisez une autre infrastructure de test, créez une bibliothèque de classes C# et reportez-vous à la documentation de l’infrastructure de test sur la configuration du projet.

L’exemple suivant crée deux contraintes sur la valeur nommée du paramètre afin que IntelliTest génère la chaîne requise :

using System;
using Microsoft.Pex.Framework;
using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public partial class HelloWorldTest {
    [PexMethod]
    public void HelloWorld([PexAssumeNotNull]string value) {
        if (value.StartsWith("Hello")
            && value.EndsWith("World!")
            && value.Contains(" "))
            throw new Exception("found it!");
    }
}

Une fois compilé et exécuté, IntelliTest génère un ensemble de tests tels que le jeu suivant :

1. ""
2. "\0\0\0\0\0"
3. « Hello »
4. "\0\0\0\0\0\0"
5. « Hello\0 »
6. « Bonjour\0\0 »
7. « Hello\0World ! »
8. « Hello World ! »

Lisez Générer des tests unitaires avec IntelliTest pour comprendre où les tests générés sont enregistrés. Le code de test généré doit inclure un test tel que le code suivant :

[TestMethod]
[PexGeneratedBy(typeof(global::HelloWorldTest))]
[PexRaisedException(typeof(Exception))]
public void HelloWorldThrowsException167()
{
    this.HelloWorld("Hello World!");
}

C’est facile !

Ressources supplémentaires :

• Lisez cette vue d’ensemble sur MSDN Magazine

Attributs importants

• PexClass marque un type contenant PUT
• PexMethod marque un PUT
• PexAssumeNotNull marque un paramètre non null

using Microsoft.Pex.Framework;

[..., PexClass(typeof(Foo))]
public partial class FooTest {
    [PexMethod]
    public void Bar([PexAssumeNotNull]Foo target, int i) {
        target.Bar(i);
    }
}

• PexAssemblyUnderTest lie un projet de test à un projet
• PexInstrumentAssembly spécifie un assembly à instrumenter

[assembly: PexAssemblyUnderTest("MyAssembly")] // also instruments "MyAssembly"
[assembly: PexInstrumentAssembly("Lib")]

Classes d’assistance statique importantes

• PexAssume évalue les hypothèses (filtrage d’entrée)
• PexAssert évalue les assertions
• PexChoose génère de nouveaux choix (entrées supplémentaires)
• PexObserve enregistre les valeurs dynamiques des tests générés

[PexMethod]
void StaticHelpers(Foo target) {
    PexAssume.IsNotNull(target);

    int i = PexChoose.Value<int>("i");
    string result = target.Bar(i);

    PexObserve.ValueForViewing<string>("result", result);
    PexAssert.IsNotNull(result);
}

Limites

Cette section décrit les limitations d’IntelliTest :

• Non déterminisme
• Concurrence
• Code .NET natif
• Plateforme
• Language
• Raisonnement symbolique
• Traces de pile

Non déterminisme

IntelliTest part du principe que le programme analysé est déterministe. Si ce n’est pas le cas, IntelliTest effectue des cycles jusqu’à ce qu’il atteigne la limite d’exploration.

IntelliTest considère qu’un programme n’est pas détermiste s’il s’appuie sur des entrées que IntelliTest ne peut pas contrôler.

IntelliTest contrôle les entrées fournies aux tests unitaires paramétrables et obtenues à partir de PexChoose. Dans ce contexte, les résultats des appels au code non géré ou non instrumenté sont également considérés comme des « entrées » dans le programme instrumenté, mais IntelliTest ne peut pas les contrôler. Si le flux de contrôle du programme dépend de valeurs spécifiques provenant de ces sources externes, IntelliTest ne peut pas « diriger » le programme vers des zones précédemment découvertes.

De plus, le programme est considéré comme non détermiste si les valeurs provenant de sources externes changent lors de la réexécution du programme. Dans ce cas, IntelliTest perd le contrôle sur l’exécution du programme et sa recherche devient inefficace.

Parfois, ce n’est pas évident quand cela se produit. Prenons les exemples suivants :

• Le résultat de la méthode GetHashCode() est fourni par du code non managé et n’est pas prévisible.
• La classe System.Random utilise l’heure système actuelle pour fournir des valeurs véritablement aléatoires.
• La classe System.DateTime fournit l’heure actuelle, qui n’est pas sous le contrôle d’IntelliTest.

Concurrency

IntelliTest ne gère pas les programmes multithreads.

Code natif

IntelliTest ne comprend pas le code natif, tel que les instructions x86 appelées via P/Invoke. Il ne sait pas comment traduire de tels appels en contraintes qui peuvent être passés au solveur de contraintes. Même pour le code .NET, il ne peut analyser que le code qu’il instrumente. IntelliTest ne peut pas instrumenter certaines parties de mscorlib, y compris la bibliothèque de réflexion. DynamicMethod ne peut pas être instrumenté.

La solution de contournement suggérée consiste à avoir un mode de test où de telles méthodes se trouvent dans des types dans un assembly dynamique. Toutefois, même si certaines méthodes ne sont pas instrumentées, IntelliTest tente de couvrir autant que possible le code instrumenté.

Platform

IntelliTest est pris en charge uniquement sur le X86, 32 bits . NETframework.

Language

En principe, IntelliTest peut analyser des programmes .NET arbitraires, écrits dans n’importe quel langage .NET. Toutefois, dans Visual Studio, il prend uniquement en charge C#.

Raisonnement symbolique

IntelliTest utilise un solveur de contrainte automatique pour déterminer quelles valeurs sont pertinentes pour le test et le programme en cours de test. Toutefois, les capacités du solveur de contraintes sont limitées et seront toujours limitées.

Traces de pile incorrectes

Comme IntelliTest intercepte et relance des exceptions dans chaque méthode instrumentée, les numéros de ligne dans les rapports de pile ne seront pas exacts. Il s’agit d’une limitation par conception de l’instruction « rethrow ».

Contenu connexe

• Article de blog introductif.
• Générer des tests unitaires pour votre code avec IntelliTest